// module.exports =
// /** ****/ (function (modules) { // webpackBootstrap
//     /** ****/ 	// The module cache
//     /** ****/ 	var installedModules = {}
//     /** ****/
//     /** ****/ 	// The require function
//     /** ****/ 	function __webpack_require__ (moduleId) {
//       /** ****/
//       /** ****/ 		// Check if module is in cache
//       /** ****/ 		if (installedModules[moduleId]) {
//         /** ****/ 			return installedModules[moduleId].exports
//         /** ****/ 		}
//       /** ****/ 		// Create a new module (and put it into the cache)
//       /** ****/ 		var module = installedModules[moduleId] = {
//         /** ****/ 			i: moduleId,
//         /** ****/ 			l: false,
//         /** ****/ 			exports: {}
//         /** ****/ 		}
//       /** ****/
//       /** ****/ 		// Execute the module function
//       /** ****/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__)
//       /** ****/
//       /** ****/ 		// Flag the module as loaded
//       /** ****/ 		module.l = true
//       /** ****/
//       /** ****/ 		// Return the exports of the module
//       /** ****/ 		return module.exports
//       /** ****/ 	}
//     /** ****/
//     /** ****/
//     /** ****/ 	// expose the modules object (__webpack_modules__)
//     /** ****/ 	__webpack_require__.m = modules
//     /** ****/
//     /** ****/ 	// expose the module cache
//     /** ****/ 	__webpack_require__.c = installedModules
//     /** ****/
//     /** ****/ 	// define getter function for harmony exports
//     /** ****/ 	__webpack_require__.d = function (exports, name, getter) {
//       /** ****/ 		if (!__webpack_require__.o(exports, name)) {
//         /** ****/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter })
//         /** ****/ 		}
//       /** ****/ 	}
//     /** ****/
//     /** ****/ 	// define __esModule on exports
//     /** ****/ 	__webpack_require__.r = function (exports) {
//       /** ****/ 		if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
//         /** ****/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
//         /** ****/ 		}
//       /** ****/ 		Object.defineProperty(exports, '__esModule', { value: true })
//       /** ****/ 	}
//     /** ****/
//     /** ****/ 	// create a fake namespace object
//     /** ****/ 	// mode & 1: value is a module id, require it
//     /** ****/ 	// mode & 2: merge all properties of value into the ns
//     /** ****/ 	// mode & 4: return value when already ns object
//     /** ****/ 	// mode & 8|1: behave like require
//     /** ****/ 	__webpack_require__.t = function (value, mode) {
//       /** ****/ 		if (mode & 1) value = __webpack_require__(value)
//       /** ****/ 		if (mode & 8) return value
//       /** ****/ 		if ((mode & 4) && typeof value === 'object' && value && value.__esModule) return value
//       /** ****/ 		var ns = Object.create(null)
//       /** ****/ 		__webpack_require__.r(ns)
//       /** ****/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value })
//       /** ****/ 		if (mode & 2 && typeof value !== 'string') for (var key in value) __webpack_require__.d(ns, key, function (key) { return value[key] }.bind(null, key))
//       /** ****/ 		return ns
//       /** ****/ 	}
//     /** ****/
//     /** ****/ 	// getDefaultExport function for compatibility with non-harmony modules
//     /** ****/ 	__webpack_require__.n = function (module) {
//       /** ****/ 		var getter = module && module.__esModule
//       /** ****/ 			? function getDefault () { return module['default'] }
//       /** ****/ 			: function getModuleExports () { return module }
//       /** ****/ 		__webpack_require__.d(getter, 'a', getter)
//       /** ****/ 		return getter
//       /** ****/ 	}
//     /** ****/
//     /** ****/ 	// Object.prototype.hasOwnProperty.call
//     /** ****/ 	__webpack_require__.o = function (object, property) { return Object.prototype.hasOwnProperty.call(object, property) }
//     /** ****/
//     /** ****/ 	// __webpack_public_path__
//     /** ****/ 	__webpack_require__.p = '/'
//     /** ****/
//     /** ****/
//     /** ****/ 	// Load entry module and return exports
//     /** ****/ 	return __webpack_require__(__webpack_require__.s = 0)
//     /** ****/ })({

//     /** */ './node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!./node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/Scope.vue?vue&type=template&id=4c74502b&scoped=true&':
//     /*! *********************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************!*\
//   !*** ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!./node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/cache-loader/dist/cjs.js??ref--2-0!./node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./src/Scope.vue?vue&type=template&id=4c74502b&scoped=true& ***!
//   \*********************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************/
//     /*! exports provided: render, staticRenderFns */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, 'render', function () { return render })
//       /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, 'staticRenderFns', function () { return staticRenderFns })
//       var render = function () {
//         var _vm = this
//         var _h = _vm.$createElement
//         var _c = _vm._self._c || _h
//         return _c(
//           'svg',
//           {
//             staticClass: 'thumbViewClass',
//             on: { click: _vm.updateMainViewPan, mousemove: _vm.updateMainViewPan }
//           },
//           [
//             _c('rect', {
//               staticClass: 'scope',
//               attrs: { x: _vm.x, y: _vm.y, width: _vm.width, height: _vm.height }
//             })
//           ]
//         )
//       }
//       var staticRenderFns = []
//       render._withStripped = true
//       /** */ },

//     /** */ './node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!./node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoom.vue?vue&type=template&id=806a3476&':
//     /*! **************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************!*\
//   !*** ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!./node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/cache-loader/dist/cjs.js??ref--2-0!./node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./src/SvgPanZoom.vue?vue&type=template&id=806a3476& ***!
//   \**************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************/
//     /*! exports provided: render, staticRenderFns */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, 'render', function () { return render })
//       /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, 'staticRenderFns', function () { return staticRenderFns })
//       var render = function () {
//         var _vm = this
//         var _h = _vm.$createElement
//         var _c = _vm._self._c || _h
//         return _c(
//           'div',
//           [
//             _vm._t('default'),
//             _vm._v(' '),
//             _vm.has_thumbnail
//               ? _c(
//                 'SvgPanZoomThumbnail',
//                 {
//                   attrs: {
//                     onThumbnailShown: _vm.onThumbnailShown,
//                     mainSPZ: _vm.spz,
//                     bus: _vm.bus
//                   }
//                 },
//                 [_vm._t('thumbnail')],
//                 2
//               )
//               : _vm._e()
//           ],
//           2
//         )
//       }
//       var staticRenderFns = []
//       render._withStripped = true
//       /** */ },

//     /** */ './node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!./node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoomThumbnail.vue?vue&type=template&id=4cd02652&':
//     /*! ***********************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************!*\
//   !*** ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!./node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/cache-loader/dist/cjs.js??ref--2-0!./node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./src/SvgPanZoomThumbnail.vue?vue&type=template&id=4cd02652& ***!
//   \***********************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************/
//     /*! exports provided: render, staticRenderFns */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, 'render', function () { return render })
//       /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, 'staticRenderFns', function () { return staticRenderFns })
//       var render = function () {
//         var _vm = this
//         var _h = _vm.$createElement
//         var _c = _vm._self._c || _h
//         return _c(
//           'div',
//           { on: { wheel: _vm.zoomMain }},
//           [
//             _c(
//               'SPZ',
//               {
//                 staticClass: 'thumbnail',
//                 attrs: {
//                   zoomEnabled: false,
//                   panEnabled: false,
//                   controlIconsEnabled: false,
//                   dblClickZoomEnabled: false,
//                   preventMouseEventsDefault: true
//                 },
//                 on: { svgpanzoom: _vm.thumbnailSPZcreated }
//               },
//               [_vm._t('default')],
//               2
//             ),
//             _vm._v(' '),
//             _c('Scope', {
//               attrs: {
//                 bus: _vm.bus,
//                 mainSPZ: _vm.mainSPZ,
//                 thumbnailSPZ: _vm.thumbnailSPZ
//               }
//             })
//           ],
//           1
//         )
//       }
//       var staticRenderFns = []
//       render._withStripped = true
//       /** */ },

//     /** */ './node_modules/css-loader/index.js?!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css&':
//     /*! ***************************************************************************************************************************************************************************************************************************************************************************************************************************!*\
//   !*** ./node_modules/css-loader??ref--3-oneOf-1-1!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js??ref--2-0!./node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./src/Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css& ***!
//   \***************************************************************************************************************************************************************************************************************************************************************************************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       exports = module.exports = __webpack_require__(/*! ../node_modules/css-loader/lib/css-base.js */ './node_modules/css-loader/lib/css-base.js')(true)
//       // imports

//       // module
//       exports.push([module.i, '\n.scope[data-v-4c74502b] {\n  fill: red;\n  fill-opacity: 0.1;\n  stroke: red;\n  stroke-width: 2px;\n}\nsvg.thumbViewClass[data-v-4c74502b] {\n  border: 1px solid black;\n  position: absolute;\n  bottom: 5px;\n  left: 5px;\n  width: 20%;\n  height: 30%;\n  margin: 3px;\n  padding: 3px;\n  overflow: hidden;\n  z-index: 120;\n}\n', '', { 'version': 3, 'sources': ['/home/yanick/work/javascript/vue-svg-pan-zoom/src/src/Scope.vue'], 'names': [], 'mappings': ';AAOA;EACA,UAAA;EACA,kBAAA;EACA,YAAA;EACA,kBAAA;CACA;AAEA;EACA,wBAAA;EACA,mBAAA;EACA,YAAA;EACA,UAAA;EACA,WAAA;EACA,YAAA;EACA,YAAA;EACA,aAAA;EACA,iBAAA;EACA,aAAA;CACA', 'file': 'Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css&', 'sourcesContent': ['<template>\n  <svg class="thumbViewClass" @click="updateMainViewPan" @mousemove="updateMainViewPan">\n    <rect class="scope" :x="x" :y="y" :width="width" :height="height"/>\n  </svg>\n</template>\n\n<style scoped>\n  .scope {\n    fill: red;\n    fill-opacity: 0.1;\n    stroke: red;\n    stroke-width: 2px;\n  }\n\n  svg.thumbViewClass {\n    border: 1px solid black;\n    position: absolute;\n    bottom: 5px;\n    left: 5px;\n    width: 20%;\n    height: 30%;\n    margin: 3px;\n    padding: 3px;\n    overflow: hidden;\n    z-index: 120;\n  }\n</style>\n\n<script>\n  function updateScope(){\n    let main = this.mainSPZ;\n    let thumb = this.thumbnailSPZ;\n\n    if( !main || !thumb ) return;\n\n    let mainPanX   = main.getPan().x\n    , mainPanY   = main.getPan().y\n    , mainWidth  = main.getSizes().width\n    , mainHeight = main.getSizes().height\n    , mainZoom   = main.getSizes().realZoom\n    , thumbPanX  = thumb.getPan().x\n    , thumbPanY  = thumb.getPan().y\n    , thumbZoom  = thumb.getSizes().realZoom;\n\n    let thumByMainZoomRatio =  thumbZoom / mainZoom;\n\n    let scopeX = thumbPanX - mainPanX * thumByMainZoomRatio;\n    let scopeY = thumbPanY - mainPanY * thumByMainZoomRatio;\n    let scopeWidth = mainWidth * thumByMainZoomRatio;\n    let scopeHeight = mainHeight * thumByMainZoomRatio;\n\n    this.x = scopeX + 1;\n    this.y = scopeY + 1;\n    this.width = scopeWidth - 2;\n    this.height = scopeHeight - 2;\n  };\n\n\n  function updateMainViewPan(evt){\n    if(evt.which == 0 && evt.button == 0){\n      return false;\n    }\n\n    let main = this.mainSPZ;\n    let thumb = this.thumbnailSPZ;\n\n    let dim = this.$el.getBoundingClientRect()\n    , mainWidth   = main.getSizes().width\n    , mainHeight  = main.getSizes().height\n    , mainZoom    = main.getSizes().realZoom\n    , thumbWidth  = thumb.getSizes().width\n    , thumbHeight = thumb.getSizes().height\n    , thumbZoom =  thumb.getSizes().realZoom;\n\n    var thumbPanX = evt.clientX - dim.left - thumbWidth / 2;\n    var thumbPanY = evt.clientY - dim.top - thumbHeight / 2;\n    var mainPanX = - thumbPanX * mainZoom / thumbZoom;\n    var mainPanY = - thumbPanY * mainZoom / thumbZoom;\n    main.pan({x:mainPanX, y:mainPanY});\n  }\n\n  export default {\n    props: [ \'bus\', \'mainSPZ\', \'thumbnailSPZ\' ],\n    data: () => ({ x: 0, y: 0, width: 0, height: 0 }),\n    watch: {\n      mainSPZ() { updateScope.call(this) },\n      thumbnailSPZ() { updateScope.call(this) },\n    },\n    mounted() {\n      const up = updateScope.bind(this);\n      [ \'mainZoom\', \'mainPan\', \'thumbnailCreated\' ].forEach( event => this.bus.$on( event, up ) );\n      up();\n    },\n    methods: {\n      updateMainViewPan\n    }\n  };\n</script>\n'], 'sourceRoot': '' }])

//       // exports
//       /** */ },

//     /** */ './node_modules/css-loader/index.js?!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css&':
//     /*! *****************************************************************************************************************************************************************************************************************************************************************************************************************!*\
//   !*** ./node_modules/css-loader??ref--3-oneOf-1-1!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js??ref--2-0!./node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./src/SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css& ***!
//   \*****************************************************************************************************************************************************************************************************************************************************************************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       exports = module.exports = __webpack_require__(/*! ../node_modules/css-loader/lib/css-base.js */ './node_modules/css-loader/lib/css-base.js')(true)
//       // imports

//       // module
//       exports.push([module.i, '\n.thumbView {\n  z-index: 110;\n  background: white;\n}\n.thumbnail {\n  position: absolute;\n  bottom: 5px;\n  left: 5px;\n  width: 20%;\n  height: 30%;\n  margin: 3px;\n  padding: 3px;\n  overflow: hidden;\n  z-index: 120;\n}\n.thumbnail svg {\n  width: 100% !important;\n  height: 100% !important;\n}\n', '', { 'version': 3, 'sources': ['/home/yanick/work/javascript/vue-svg-pan-zoom/src/src/SvgPanZoomThumbnail.vue'], 'names': [], 'mappings': ';AAiBA;EACA,aAAA;EACA,kBAAA;CACA;AAEA;EACA,mBAAA;EACA,YAAA;EACA,UAAA;EACA,WAAA;EACA,YAAA;EACA,YAAA;EACA,aAAA;EACA,iBAAA;EACA,aAAA;CACA;AAEA;EACA,uBAAA;EACA,wBAAA;CACA', 'file': 'SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css&', 'sourcesContent': ['<template>\n  <div v-on:wheel="zoomMain">\n    <SPZ class="thumbnail"\n      :zoomEnabled="false"\n      :panEnabled="false"\n      :controlIconsEnabled="false"\n      :dblClickZoomEnabled="false"\n      :preventMouseEventsDefault="true"\n      v-on:svgpanzoom="thumbnailSPZcreated"\n    >\n      <slot class="thumbnail" />\n    </SPZ>\n    <Scope :bus="bus" :mainSPZ="mainSPZ" :thumbnailSPZ="thumbnailSPZ" />\n  </div>\n</template>\n\n<style>\n  .thumbView {\n    z-index: 110;\n    background: white;\n  }\n\n  .thumbnail {\n    position: absolute;\n    bottom: 5px;\n    left: 5px;\n    width: 20%;\n    height: 30%;\n    margin: 3px;\n    padding: 3px;\n    overflow: hidden;\n    z-index: 120;\n  }\n\n  .thumbnail svg {\n    width: 100% !important;\n    height: 100% !important;\n  }\n</style>\n\n<script>\nimport Scope from \'./Scope.vue\';\n\nexport default {\n  components: { Scope },\n  props: [ \'onThumbnailShown\', \'mainSPZ\', \'bus\' ],\n  data: () => ({ thumbnailSPZ: null }),\n  beforeCreate: function () {\n    this.$options.components.SPZ = require(\'./SvgPanZoom.vue\').default\n  },\n  methods: {\n    zoomMain(evt) {\n      this.mainSPZ[ event.deltaY < 0 ? \'zoomIn\' : \'zoomOut\' ]();\n    },\n    thumbnailSPZcreated(spz) {\n      this.thumbnailSPZ = spz;\n      this.bus.$emit( \'thumbnailCreated\', spz );\n    },\n  },\n  mounted() {\n    if( this.onThumbnailShown ) {\n      this.onThumbnailShown();\n    }\n  }\n};\n</script>\n'], 'sourceRoot': '' }])

//       // exports
//       /** */ },

//     /** */ './node_modules/css-loader/lib/css-base.js':
//     /*! *************************************************!*\
//   !*** ./node_modules/css-loader/lib/css-base.js ***!
//   \*************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports) {
//       /*
// 	MIT License http://www.opensource.org/licenses/mit-license.php
// 	Author Tobias Koppers @sokra
// */
//       // css base code, injected by the css-loader
//       module.exports = function (useSourceMap) {
//         var list = []

//         // return the list of modules as css string
//         list.toString = function toString () {
//           return this.map(function (item) {
//             var content = cssWithMappingToString(item, useSourceMap)
//             if (item[2]) {
//               return '@media ' + item[2] + '{' + content + '}'
//             } else {
//               return content
//             }
//           }).join('')
//         }

//         // import a list of modules into the list
//         list.i = function (modules, mediaQuery) {
//           if (typeof modules === 'string') { modules = [[null, modules, '']] }
//           var alreadyImportedModules = {}
//           for (var i = 0; i < this.length; i++) {
//             var id = this[i][0]
//             if (typeof id === 'number') { alreadyImportedModules[id] = true }
//           }
//           for (i = 0; i < modules.length; i++) {
//             var item = modules[i]
//             // skip already imported module
//             // this implementation is not 100% perfect for weird media query combinations
//             //  when a module is imported multiple times with different media queries.
//             //  I hope this will never occur (Hey this way we have smaller bundles)
//             if (typeof item[0] !== 'number' || !alreadyImportedModules[item[0]]) {
//               if (mediaQuery && !item[2]) {
//                 item[2] = mediaQuery
//               } else if (mediaQuery) {
//                 item[2] = '(' + item[2] + ') and (' + mediaQuery + ')'
//               }
//               list.push(item)
//             }
//           }
//         }
//         return list
//       }

//       function cssWithMappingToString (item, useSourceMap) {
//         var content = item[1] || ''
//         var cssMapping = item[3]
//         if (!cssMapping) {
//           return content
//         }

//         if (useSourceMap && typeof btoa === 'function') {
//           var sourceMapping = toComment(cssMapping)
//           var sourceURLs = cssMapping.sources.map(function (source) {
//             return '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */'
//           })

//           return [content].concat(sourceURLs).concat([sourceMapping]).join('\n')
//         }

//         return [content].join('\n')
//       }

//       // Adapted from convert-source-map (MIT)
//       function toComment (sourceMap) {
//         // eslint-disable-next-line no-undef
//         var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))))
//         var data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64

//         return '/*# ' + data + ' */'
//       }
//       /** */ },

//     /** */ './node_modules/poi/lib/webpack/babel-loader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/Scope.vue?vue&type=script&lang=js&':
//     /*! ******************************************************************************************************************************************************************************************************************************!*\
//   !*** ./node_modules/poi/lib/webpack/babel-loader.js??ref--1-0!./node_modules/cache-loader/dist/cjs.js??ref--2-0!./node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./src/Scope.vue?vue&type=script&lang=js& ***!
//   \******************************************************************************************************************************************************************************************************************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       function updateScope () {
//         var main = this.mainSPZ
//         var thumb = this.thumbnailSPZ
//         if (!main || !thumb) return
//         var mainPanX = main.getPan().x
//         var mainPanY = main.getPan().y
//         var mainWidth = main.getSizes().width
//         var mainHeight = main.getSizes().height
//         var mainZoom = main.getSizes().realZoom
//         var thumbPanX = thumb.getPan().x
//         var thumbPanY = thumb.getPan().y
//         var thumbZoom = thumb.getSizes().realZoom
//         var thumByMainZoomRatio = thumbZoom / mainZoom
//         var scopeX = thumbPanX - mainPanX * thumByMainZoomRatio
//         var scopeY = thumbPanY - mainPanY * thumByMainZoomRatio
//         var scopeWidth = mainWidth * thumByMainZoomRatio
//         var scopeHeight = mainHeight * thumByMainZoomRatio
//         this.x = scopeX + 1
//         this.y = scopeY + 1
//         this.width = scopeWidth - 2
//         this.height = scopeHeight - 2
//       }

//       function updateMainViewPan (evt) {
//         if (evt.which == 0 && evt.button == 0) {
//           return false
//         }

//         var main = this.mainSPZ
//         var thumb = this.thumbnailSPZ
//         var dim = this.$el.getBoundingClientRect()
//         var mainWidth = main.getSizes().width
//         var mainHeight = main.getSizes().height
//         var mainZoom = main.getSizes().realZoom
//         var thumbWidth = thumb.getSizes().width
//         var thumbHeight = thumb.getSizes().height
//         var thumbZoom = thumb.getSizes().realZoom
//         var thumbPanX = evt.clientX - dim.left - thumbWidth / 2
//         var thumbPanY = evt.clientY - dim.top - thumbHeight / 2
//         var mainPanX = -thumbPanX * mainZoom / thumbZoom
//         var mainPanY = -thumbPanY * mainZoom / thumbZoom
//         main.pan({
//           x: mainPanX,
//           y: mainPanY
//         })
//       }

//       /* harmony default export */ __webpack_exports__['default'] = ({
//         props: ['bus', 'mainSPZ', 'thumbnailSPZ'],
//         data: function data () {
//           return {
//             x: 0,
//             y: 0,
//             width: 0,
//             height: 0
//           }
//         },
//         watch: {
//           mainSPZ: function mainSPZ () {
//             updateScope.call(this)
//           },
//           thumbnailSPZ: function thumbnailSPZ () {
//             updateScope.call(this)
//           }
//         },
//         mounted: function mounted () {
//           var _this = this

//           var up = updateScope.bind(this);
//           ['mainZoom', 'mainPan', 'thumbnailCreated'].forEach(function (event) {
//             return _this.bus.$on(event, up)
//           })
//           up()
//         },
//         methods: {
//           updateMainViewPan: updateMainViewPan
//         }
//       })
//       /** */ },

//     /** */ './node_modules/poi/lib/webpack/babel-loader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoom.vue?vue&type=script&lang=js&':
//     /*! ***********************************************************************************************************************************************************************************************************************************!*\
//   !*** ./node_modules/poi/lib/webpack/babel-loader.js??ref--1-0!./node_modules/cache-loader/dist/cjs.js??ref--2-0!./node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./src/SvgPanZoom.vue?vue&type=script&lang=js& ***!
//   \***********************************************************************************************************************************************************************************************************************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var svg_pan_zoom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svg-pan-zoom */ './node_modules/svg-pan-zoom/src/browserify.js')
//       /* harmony import */ var svg_pan_zoom__WEBPACK_IMPORTED_MODULE_0___default = /* #__PURE__*/__webpack_require__.n(svg_pan_zoom__WEBPACK_IMPORTED_MODULE_0__)
//       /* harmony import */ var _props__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./props */ './src/props.js')
//       /* harmony import */ var _EventBus__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./EventBus */ './src/EventBus.js')
//       /* harmony import */ var _SvgPanZoomThumbnail_vue__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./SvgPanZoomThumbnail.vue */ './src/SvgPanZoomThumbnail.vue')
//       /* harmony import */ var _SvgPanZoomApi__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./SvgPanZoomApi */ './src/SvgPanZoomApi.js')
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //

//       /* harmony default export */ __webpack_exports__['default'] = ({
//         components: {
//           SvgPanZoomThumbnail: _SvgPanZoomThumbnail_vue__WEBPACK_IMPORTED_MODULE_3__['default']
//         },
//         props: _props__WEBPACK_IMPORTED_MODULE_1__['default'],
//         computed: {
//           has_thumbnail: function has_thumbnail () {
//             return this.$slots.thumbnail
//           },
//           options: function options () {
//             var _this = this

//             var options = {}

//             var is_defined = function is_defined (k) {
//               return _this[k] !== undefined
//             }

//             Object.keys(_props__WEBPACK_IMPORTED_MODULE_1__['default']).filter(is_defined).forEach(function (k) {
//               return options[k] = _this[k]
//             })
//             return options
//           }
//         },
//         data: function data () {
//           return {
//             spz: null,
//             bus: Object(_EventBus__WEBPACK_IMPORTED_MODULE_2__['EventBus'])()
//           }
//         },
//         mounted: function mounted () {
//           var _this2 = this

//           var options = {}
//           Object.keys(_props__WEBPACK_IMPORTED_MODULE_1__['default']).filter(function (k) {
//             return _this2[k] !== undefined
//           }).forEach(function (k) {
//             return options[k] = _this2[k]
//           })

//           options.onZoom = function () {
//             _this2.bus.$emit('mainZoom')

//             for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
//               args[_key] = arguments[_key]
//             }

//             if (_this2.onZoom) _this2.onZoom(args)
//           }

//           options.onPan = function () {
//             _this2.bus.$emit('mainPan')

//             for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
//               args[_key2] = arguments[_key2]
//             }

//             if (_this2.onPan) _this2.onPan(args)
//           }
//           options.onRegionChange = function (val, type) {
//             _this2.$emit('RegionCheck', val, type)
//           }
//           this.spz = svg_pan_zoom__WEBPACK_IMPORTED_MODULE_0___default()(this.$slots['default'][0].elm, options)
//           this.$emit('svgpanzoom', this.spz)
//         },
//         methods: {
//           zoom: function zoom (v) {
//             this.spz.zoom(v)
//           },
//           zoomBy: function zoomBy (v) {
//             this.spz.zoomBy(v)
//           }
//         }
//       })
//       /** */ },

//     /** */ './node_modules/poi/lib/webpack/babel-loader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoomThumbnail.vue?vue&type=script&lang=js&':
//     /*! ********************************************************************************************************************************************************************************************************************************************!*\
//   !*** ./node_modules/poi/lib/webpack/babel-loader.js??ref--1-0!./node_modules/cache-loader/dist/cjs.js??ref--2-0!./node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./src/SvgPanZoomThumbnail.vue?vue&type=script&lang=js& ***!
//   \********************************************************************************************************************************************************************************************************************************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _Scope_vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Scope.vue */ './src/Scope.vue')
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //
//       //

//       /* harmony default export */ __webpack_exports__['default'] = ({
//         components: {
//           Scope: _Scope_vue__WEBPACK_IMPORTED_MODULE_0__['default']
//         },
//         props: ['onThumbnailShown', 'mainSPZ', 'bus'],
//         data: function data () {
//           return {
//             thumbnailSPZ: null
//           }
//         },
//         beforeCreate: function beforeCreate () {
//           this.$options.components.SPZ = __webpack_require__(/*! ./SvgPanZoom.vue */ './src/SvgPanZoom.vue')['default']
//         },
//         methods: {
//           zoomMain: function zoomMain (evt) {
//             this.mainSPZ[event.deltaY < 0 ? 'zoomIn' : 'zoomOut']()
//           },
//           thumbnailSPZcreated: function thumbnailSPZcreated (spz) {
//             this.thumbnailSPZ = spz
//             this.bus.$emit('thumbnailCreated', spz)
//           }
//         },
//         mounted: function mounted () {
//           if (this.onThumbnailShown) {
//             this.onThumbnailShown()
//           }
//         }
//       })
//       /** */ },

//     /** */ './node_modules/poi/node_modules/vue-loader/lib/runtime/componentNormalizer.js':
//     /*! *************************************************************************************!*\
//   !*** ./node_modules/poi/node_modules/vue-loader/lib/runtime/componentNormalizer.js ***!
//   \*************************************************************************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, 'default', function () { return normalizeComponent })
//       /* globals __VUE_SSR_CONTEXT__ */

//       // IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
//       // This module is a runtime utility for cleaner component module output and will
//       // be included in the final webpack user bundle.

//       function normalizeComponent (
//         scriptExports,
//         render,
//         staticRenderFns,
//         functionalTemplate,
//         injectStyles,
//         scopeId,
//         moduleIdentifier, /* server only */
//         shadowMode /* vue-cli only */
//       ) {
//         // Vue.extend constructor export interop
//         var options = typeof scriptExports === 'function'
//           ? scriptExports.options
//           : scriptExports

//         // render functions
//         if (render) {
//           options.render = render
//           options.staticRenderFns = staticRenderFns
//           options._compiled = true
//         }

//         // functional template
//         if (functionalTemplate) {
//           options.functional = true
//         }

//         // scopedId
//         if (scopeId) {
//           options._scopeId = 'data-v-' + scopeId
//         }

//         var hook
//         if (moduleIdentifier) { // server build
//           hook = function (context) {
//             // 2.3 injection
//             context =
//         context || // cached call
//         (this.$vnode && this.$vnode.ssrContext) || // stateful
//         (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
//             // 2.2 with runInNewContext: true
//             if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
//               context = __VUE_SSR_CONTEXT__
//             }
//             // inject component styles
//             if (injectStyles) {
//               injectStyles.call(this, context)
//             }
//             // register component module identifier for async chunk inferrence
//             if (context && context._registeredComponents) {
//               context._registeredComponents.add(moduleIdentifier)
//             }
//           }
//           // used by ssr in case component is cached and beforeCreate
//           // never gets called
//           options._ssrRegister = hook
//         } else if (injectStyles) {
//           hook = shadowMode
//             ? function () { injectStyles.call(this, this.$root.$options.shadowRoot) }
//             : injectStyles
//         }

//         if (hook) {
//           if (options.functional) {
//             // for template-only hot-reload because in that case the render fn doesn't
//             // go through the normalizer
//             options._injectStyles = hook
//             // register for functioal component in vue file
//             var originalRender = options.render
//             options.render = function renderWithStyleInjection (h, context) {
//               hook.call(context)
//               return originalRender(h, context)
//             }
//           } else {
//             // inject component registration as beforeCreate hook
//             var existing = options.beforeCreate
//             options.beforeCreate = existing
//               ? [].concat(existing, hook)
//               : [hook]
//           }
//         }

//         return {
//           exports: scriptExports,
//           options: options
//         }
//       }
//       /** */ },

//     /** */ './node_modules/process/browser.js':
//     /*! *****************************************!*\
//   !*** ./node_modules/process/browser.js ***!
//   \*****************************************/
//     /*! no static exports found */
//     /** */ function (module, exports) {
//       // shim for using process in browser
//       var process = module.exports = {}

//       // cached from whatever global is present so that test runners that stub it
//       // don't break things.  But we need to wrap it in a try catch in case it is
//       // wrapped in strict mode code which doesn't define any globals.  It's inside a
//       // function because try/catches deoptimize in certain engines.

//       var cachedSetTimeout
//       var cachedClearTimeout

//       function defaultSetTimout () {
//         throw new Error('setTimeout has not been defined')
//       }
//       function defaultClearTimeout () {
//         throw new Error('clearTimeout has not been defined')
//       }
//       (function () {
//         try {
//           if (typeof setTimeout === 'function') {
//             cachedSetTimeout = setTimeout
//           } else {
//             cachedSetTimeout = defaultSetTimout
//           }
//         } catch (e) {
//           cachedSetTimeout = defaultSetTimout
//         }
//         try {
//           if (typeof clearTimeout === 'function') {
//             cachedClearTimeout = clearTimeout
//           } else {
//             cachedClearTimeout = defaultClearTimeout
//           }
//         } catch (e) {
//           cachedClearTimeout = defaultClearTimeout
//         }
//       }())
//       function runTimeout (fun) {
//         if (cachedSetTimeout === setTimeout) {
//         // normal enviroments in sane situations
//           return setTimeout(fun, 0)
//         }
//         // if setTimeout wasn't available but was latter defined
//         if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
//           cachedSetTimeout = setTimeout
//           return setTimeout(fun, 0)
//         }
//         try {
//         // when when somebody has screwed with setTimeout but no I.E. maddness
//           return cachedSetTimeout(fun, 0)
//         } catch (e) {
//           try {
//             // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
//             return cachedSetTimeout.call(null, fun, 0)
//           } catch (e) {
//             // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
//             return cachedSetTimeout.call(this, fun, 0)
//           }
//         }
//       }
//       function runClearTimeout (marker) {
//         if (cachedClearTimeout === clearTimeout) {
//         // normal enviroments in sane situations
//           return clearTimeout(marker)
//         }
//         // if clearTimeout wasn't available but was latter defined
//         if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
//           cachedClearTimeout = clearTimeout
//           return clearTimeout(marker)
//         }
//         try {
//         // when when somebody has screwed with setTimeout but no I.E. maddness
//           return cachedClearTimeout(marker)
//         } catch (e) {
//           try {
//             // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
//             return cachedClearTimeout.call(null, marker)
//           } catch (e) {
//             // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
//             // Some versions of I.E. have different rules for clearTimeout vs setTimeout
//             return cachedClearTimeout.call(this, marker)
//           }
//         }
//       }
//       var queue = []
//       var draining = false
//       var currentQueue
//       var queueIndex = -1

//       function cleanUpNextTick () {
//         if (!draining || !currentQueue) {
//           return
//         }
//         draining = false
//         if (currentQueue.length) {
//           queue = currentQueue.concat(queue)
//         } else {
//           queueIndex = -1
//         }
//         if (queue.length) {
//           drainQueue()
//         }
//       }

//       function drainQueue () {
//         if (draining) {
//           return
//         }
//         var timeout = runTimeout(cleanUpNextTick)
//         draining = true

//         var len = queue.length
//         while (len) {
//           currentQueue = queue
//           queue = []
//           while (++queueIndex < len) {
//             if (currentQueue) {
//               currentQueue[queueIndex].run()
//             }
//           }
//           queueIndex = -1
//           len = queue.length
//         }
//         currentQueue = null
//         draining = false
//         runClearTimeout(timeout)
//       }

//       process.nextTick = function (fun) {
//         var args = new Array(arguments.length - 1)
//         if (arguments.length > 1) {
//           for (var i = 1; i < arguments.length; i++) {
//             args[i - 1] = arguments[i]
//           }
//         }
//         queue.push(new Item(fun, args))
//         if (queue.length === 1 && !draining) {
//           runTimeout(drainQueue)
//         }
//       }

//       // v8 likes predictible objects
//       function Item (fun, array) {
//         this.fun = fun
//         this.array = array
//       }
//       Item.prototype.run = function () {
//         this.fun.apply(null, this.array)
//       }
//       process.title = 'browser'
//       process.browser = true
//       process.env = {}
//       process.argv = []
//       process.version = '' // empty string to avoid regexp issues
//       process.versions = {}

//       function noop () {}

//       process.on = noop
//       process.addListener = noop
//       process.once = noop
//       process.off = noop
//       process.removeListener = noop
//       process.removeAllListeners = noop
//       process.emit = noop
//       process.prependListener = noop
//       process.prependOnceListener = noop

//       process.listeners = function (name) { return [] }

//       process.binding = function (name) {
//         throw new Error('process.binding is not supported')
//       }

//       process.cwd = function () { return '/' }
//       process.chdir = function (dir) {
//         throw new Error('process.chdir is not supported')
//       }
//       process.umask = function () { return 0 }
//       /** */ },

//     /** */ './node_modules/setimmediate/setImmediate.js':
//     /*! ***************************************************!*\
//   !*** ./node_modules/setimmediate/setImmediate.js ***!
//   \***************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       /* WEBPACK VAR INJECTION */(function (global, process) {
//         (function (global, undefined) {
//           'use strict'

//           if (global.setImmediate) {
//             return
//           }

//           var nextHandle = 1 // Spec says greater than zero
//           var tasksByHandle = {}
//           var currentlyRunningATask = false
//           var doc = global.document
//           var registerImmediate

//           function setImmediate (callback) {
//           // Callback can either be a function or a string
//             if (typeof callback !== 'function') {
//               callback = new Function('' + callback)
//             }
//             // Copy function arguments
//             var args = new Array(arguments.length - 1)
//             for (var i = 0; i < args.length; i++) {
//               args[i] = arguments[i + 1]
//             }
//             // Store and register the task
//             var task = { callback: callback, args: args }
//             tasksByHandle[nextHandle] = task
//             registerImmediate(nextHandle)
//             return nextHandle++
//           }

//           function clearImmediate (handle) {
//             delete tasksByHandle[handle]
//           }

//           function run (task) {
//             var callback = task.callback
//             var args = task.args
//             switch (args.length) {
//               case 0:
//                 callback()
//                 break
//               case 1:
//                 callback(args[0])
//                 break
//               case 2:
//                 callback(args[0], args[1])
//                 break
//               case 3:
//                 callback(args[0], args[1], args[2])
//                 break
//               default:
//                 callback.apply(undefined, args)
//                 break
//             }
//           }

//           function runIfPresent (handle) {
//             // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
//             // So if we're currently running a task, we'll need to delay this invocation.
//             if (currentlyRunningATask) {
//             // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
//             // "too much recursion" error.
//               setTimeout(runIfPresent, 0, handle)
//             } else {
//               var task = tasksByHandle[handle]
//               if (task) {
//                 currentlyRunningATask = true
//                 try {
//                   run(task)
//                 } finally {
//                   clearImmediate(handle)
//                   currentlyRunningATask = false
//                 }
//               }
//             }
//           }

//           function installNextTickImplementation () {
//             registerImmediate = function (handle) {
//               process.nextTick(function () { runIfPresent(handle) })
//             }
//           }

//           function canUsePostMessage () {
//             // The test against `importScripts` prevents this implementation from being installed inside a web worker,
//             // where `global.postMessage` means something completely different and can't be used for this purpose.
//             if (global.postMessage && !global.importScripts) {
//               var postMessageIsAsynchronous = true
//               var oldOnMessage = global.onmessage
//               global.onmessage = function () {
//                 postMessageIsAsynchronous = false
//               }
//               global.postMessage('', '*')
//               global.onmessage = oldOnMessage
//               return postMessageIsAsynchronous
//             }
//           }

//           function installPostMessageImplementation () {
//             // Installs an event handler on `global` for the `message` event: see
//             // * https://developer.mozilla.org/en/DOM/window.postMessage
//             // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages

//             var messagePrefix = 'setImmediate$' + Math.random() + '$'
//             var onGlobalMessage = function (event) {
//               if (event.source === global &&
//                 typeof event.data === 'string' &&
//                 event.data.indexOf(messagePrefix) === 0) {
//                 runIfPresent(+event.data.slice(messagePrefix.length))
//               }
//             }

//             if (global.addEventListener) {
//               global.addEventListener('message', onGlobalMessage, false)
//             } else {
//               global.attachEvent('onmessage', onGlobalMessage)
//             }

//             registerImmediate = function (handle) {
//               global.postMessage(messagePrefix + handle, '*')
//             }
//           }

//           function installMessageChannelImplementation () {
//             var channel = new MessageChannel()
//             channel.port1.onmessage = function (event) {
//               var handle = event.data
//               runIfPresent(handle)
//             }

//             registerImmediate = function (handle) {
//               channel.port2.postMessage(handle)
//             }
//           }

//           function installReadyStateChangeImplementation () {
//             var html = doc.documentElement
//             registerImmediate = function (handle) {
//             // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
//             // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
//               var script = doc.createElement('script')
//               script.onreadystatechange = function () {
//                 runIfPresent(handle)
//                 script.onreadystatechange = null
//                 html.removeChild(script)
//                 script = null
//               }
//               html.appendChild(script)
//             }
//           }

//           function installSetTimeoutImplementation () {
//             registerImmediate = function (handle) {
//               setTimeout(runIfPresent, 0, handle)
//             }
//           }

//           // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
//           var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global)
//           attachTo = attachTo && attachTo.setTimeout ? attachTo : global

//           // Don't get fooled by e.g. browserify environments.
//           if ({}.toString.call(global.process) === '[object process]') {
//             // For Node.js before 0.9
//             installNextTickImplementation()
//           } else if (canUsePostMessage()) {
//             // For non-IE10 modern browsers
//             installPostMessageImplementation()
//           } else if (global.MessageChannel) {
//             // For web workers, where supported
//             installMessageChannelImplementation()
//           } else if (doc && 'onreadystatechange' in doc.createElement('script')) {
//             // For IE 6–8
//             installReadyStateChangeImplementation()
//           } else {
//             // For older browsers
//             installSetTimeoutImplementation()
//           }

//           attachTo.setImmediate = setImmediate
//           attachTo.clearImmediate = clearImmediate
//         }(typeof self === 'undefined' ? typeof global === 'undefined' ? this : global : self))
//         /* WEBPACK VAR INJECTION */ }.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ './node_modules/webpack/buildin/global.js'), __webpack_require__(/*! ./../process/browser.js */ './node_modules/process/browser.js')))
//       /** */ },

//     /** */ './node_modules/svg-pan-zoom/src/browserify.js':
//     /*! *****************************************************!*\
//   !*** ./node_modules/svg-pan-zoom/src/browserify.js ***!
//   \*****************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       var SvgPanZoom = __webpack_require__(/*! ./svg-pan-zoom.js */ './node_modules/svg-pan-zoom/src/svg-pan-zoom.js')

//       module.exports = SvgPanZoom
//       /** */ },

//     /** */ './node_modules/svg-pan-zoom/src/control-icons.js':
//     /*! ********************************************************!*\
//   !*** ./node_modules/svg-pan-zoom/src/control-icons.js ***!
//   \********************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       var SvgUtils = __webpack_require__(/*! ./svg-utilities */ './node_modules/svg-pan-zoom/src/svg-utilities.js')

//       module.exports = {
//         enable: function (instance) {
//           // Select (and create if necessary) defs
//           var defs = instance.svg.querySelector('defs')
//           if (!defs) {
//             defs = document.createElementNS(SvgUtils.svgNS, 'defs')
//             instance.svg.appendChild(defs)
//           }

//           // Check for style element, and create it if it doesn't exist
//           var styleEl = defs.querySelector('style#svg-pan-zoom-controls-styles')
//           if (!styleEl) {
//             var style = document.createElementNS(SvgUtils.svgNS, 'style')
//             style.setAttribute('id', 'svg-pan-zoom-controls-styles')
//             style.setAttribute('type', 'text/css')
//             style.textContent = '.svg-pan-zoom-control { cursor: pointer; fill: black; fill-opacity: 0.333; } .svg-pan-zoom-control:hover { fill-opacity: 0.8; } .svg-pan-zoom-control-background { fill: white; fill-opacity: 0.5; } .svg-pan-zoom-control-background { fill-opacity: 0.8; }'
//             defs.appendChild(style)
//           }

//           // Zoom Group
//           var zoomGroup = document.createElementNS(SvgUtils.svgNS, 'g')
//           zoomGroup.setAttribute('id', 'svg-pan-zoom-controls')
//           zoomGroup.setAttribute('transform', 'translate(' + (instance.width - 70) + ' ' + (instance.height - 76) + ') scale(0.75)')
//           zoomGroup.setAttribute('class', 'svg-pan-zoom-control')

//           // Control elements
//           zoomGroup.appendChild(this._createZoomIn(instance))
//           zoomGroup.appendChild(this._createZoomReset(instance))
//           zoomGroup.appendChild(this._createZoomOut(instance))

//           // Finally append created element
//           instance.svg.appendChild(zoomGroup)

//           // Cache control instance
//           instance.controlIcons = zoomGroup
//         },

//         _createZoomIn: function (instance) {
//           var zoomIn = document.createElementNS(SvgUtils.svgNS, 'g')
//           zoomIn.setAttribute('id', 'svg-pan-zoom-zoom-in')
//           zoomIn.setAttribute('transform', 'translate(30.5 5) scale(0.015)')
//           zoomIn.setAttribute('class', 'svg-pan-zoom-control')
//           zoomIn.addEventListener('click', function () { instance.getPublicInstance().zoomIn() }, false)
//           zoomIn.addEventListener('touchstart', function () { instance.getPublicInstance().zoomIn() }, false)

//           var zoomInBackground = document.createElementNS(SvgUtils.svgNS, 'rect') // TODO change these background space fillers to rounded rectangles so they look prettier
//           zoomInBackground.setAttribute('x', '0')
//           zoomInBackground.setAttribute('y', '0')
//           zoomInBackground.setAttribute('width', '1500') // larger than expected because the whole group is transformed to scale down
//           zoomInBackground.setAttribute('height', '1400')
//           zoomInBackground.setAttribute('class', 'svg-pan-zoom-control-background')
//           zoomIn.appendChild(zoomInBackground)

//           var zoomInShape = document.createElementNS(SvgUtils.svgNS, 'path')
//           zoomInShape.setAttribute('d', 'M1280 576v128q0 26 -19 45t-45 19h-320v320q0 26 -19 45t-45 19h-128q-26 0 -45 -19t-19 -45v-320h-320q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h320v-320q0 -26 19 -45t45 -19h128q26 0 45 19t19 45v320h320q26 0 45 19t19 45zM1536 1120v-960 q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5t84.5 -203.5z')
//           zoomInShape.setAttribute('class', 'svg-pan-zoom-control-element')
//           zoomIn.appendChild(zoomInShape)

//           return zoomIn
//         },

//         _createZoomReset: function (instance) {
//           // reset
//           var resetPanZoomControl = document.createElementNS(SvgUtils.svgNS, 'g')
//           resetPanZoomControl.setAttribute('id', 'svg-pan-zoom-reset-pan-zoom')
//           resetPanZoomControl.setAttribute('transform', 'translate(5 35) scale(0.4)')
//           resetPanZoomControl.setAttribute('class', 'svg-pan-zoom-control')
//           resetPanZoomControl.addEventListener('click', function () { instance.getPublicInstance().reset() }, false)
//           resetPanZoomControl.addEventListener('touchstart', function () { instance.getPublicInstance().reset() }, false)

//           var resetPanZoomControlBackground = document.createElementNS(SvgUtils.svgNS, 'rect') // TODO change these background space fillers to rounded rectangles so they look prettier
//           resetPanZoomControlBackground.setAttribute('x', '2')
//           resetPanZoomControlBackground.setAttribute('y', '2')
//           resetPanZoomControlBackground.setAttribute('width', '182') // larger than expected because the whole group is transformed to scale down
//           resetPanZoomControlBackground.setAttribute('height', '58')
//           resetPanZoomControlBackground.setAttribute('class', 'svg-pan-zoom-control-background')
//           resetPanZoomControl.appendChild(resetPanZoomControlBackground)

//           var resetPanZoomControlShape1 = document.createElementNS(SvgUtils.svgNS, 'path')
//           resetPanZoomControlShape1.setAttribute('d', 'M33.051,20.632c-0.742-0.406-1.854-0.609-3.338-0.609h-7.969v9.281h7.769c1.543,0,2.701-0.188,3.473-0.562c1.365-0.656,2.048-1.953,2.048-3.891C35.032,22.757,34.372,21.351,33.051,20.632z')
//           resetPanZoomControlShape1.setAttribute('class', 'svg-pan-zoom-control-element')
//           resetPanZoomControl.appendChild(resetPanZoomControlShape1)

//           var resetPanZoomControlShape2 = document.createElementNS(SvgUtils.svgNS, 'path')
//           resetPanZoomControlShape2.setAttribute('d', 'M170.231,0.5H15.847C7.102,0.5,0.5,5.708,0.5,11.84v38.861C0.5,56.833,7.102,61.5,15.847,61.5h154.384c8.745,0,15.269-4.667,15.269-10.798V11.84C185.5,5.708,178.976,0.5,170.231,0.5z M42.837,48.569h-7.969c-0.219-0.766-0.375-1.383-0.469-1.852c-0.188-0.969-0.289-1.961-0.305-2.977l-0.047-3.211c-0.03-2.203-0.41-3.672-1.142-4.406c-0.732-0.734-2.103-1.102-4.113-1.102h-7.05v13.547h-7.055V14.022h16.524c2.361,0.047,4.178,0.344,5.45,0.891c1.272,0.547,2.351,1.352,3.234,2.414c0.731,0.875,1.31,1.844,1.737,2.906s0.64,2.273,0.64,3.633c0,1.641-0.414,3.254-1.242,4.84s-2.195,2.707-4.102,3.363c1.594,0.641,2.723,1.551,3.387,2.73s0.996,2.98,0.996,5.402v2.32c0,1.578,0.063,2.648,0.19,3.211c0.19,0.891,0.635,1.547,1.333,1.969V48.569z M75.579,48.569h-26.18V14.022h25.336v6.117H56.454v7.336h16.781v6H56.454v8.883h19.125V48.569z M104.497,46.331c-2.44,2.086-5.887,3.129-10.34,3.129c-4.548,0-8.125-1.027-10.731-3.082s-3.909-4.879-3.909-8.473h6.891c0.224,1.578,0.662,2.758,1.316,3.539c1.196,1.422,3.246,2.133,6.15,2.133c1.739,0,3.151-0.188,4.236-0.562c2.058-0.719,3.087-2.055,3.087-4.008c0-1.141-0.504-2.023-1.512-2.648c-1.008-0.609-2.607-1.148-4.796-1.617l-3.74-0.82c-3.676-0.812-6.201-1.695-7.576-2.648c-2.328-1.594-3.492-4.086-3.492-7.477c0-3.094,1.139-5.664,3.417-7.711s5.623-3.07,10.036-3.07c3.685,0,6.829,0.965,9.431,2.895c2.602,1.93,3.966,4.73,4.093,8.402h-6.938c-0.128-2.078-1.057-3.555-2.787-4.43c-1.154-0.578-2.587-0.867-4.301-0.867c-1.907,0-3.428,0.375-4.565,1.125c-1.138,0.75-1.706,1.797-1.706,3.141c0,1.234,0.561,2.156,1.682,2.766c0.721,0.406,2.25,0.883,4.589,1.43l6.063,1.43c2.657,0.625,4.648,1.461,5.975,2.508c2.059,1.625,3.089,3.977,3.089,7.055C108.157,41.624,106.937,44.245,104.497,46.331z M139.61,48.569h-26.18V14.022h25.336v6.117h-18.281v7.336h16.781v6h-16.781v8.883h19.125V48.569z M170.337,20.14h-10.336v28.43h-7.266V20.14h-10.383v-6.117h27.984V20.14z')
//           resetPanZoomControlShape2.setAttribute('class', 'svg-pan-zoom-control-element')
//           resetPanZoomControl.appendChild(resetPanZoomControlShape2)

//           return resetPanZoomControl
//         },

//         _createZoomOut: function (instance) {
//           // zoom out
//           var zoomOut = document.createElementNS(SvgUtils.svgNS, 'g')
//           zoomOut.setAttribute('id', 'svg-pan-zoom-zoom-out')
//           zoomOut.setAttribute('transform', 'translate(30.5 70) scale(0.015)')
//           zoomOut.setAttribute('class', 'svg-pan-zoom-control')
//           zoomOut.addEventListener('click', function () { instance.getPublicInstance().zoomOut() }, false)
//           zoomOut.addEventListener('touchstart', function () { instance.getPublicInstance().zoomOut() }, false)

//           var zoomOutBackground = document.createElementNS(SvgUtils.svgNS, 'rect') // TODO change these background space fillers to rounded rectangles so they look prettier
//           zoomOutBackground.setAttribute('x', '0')
//           zoomOutBackground.setAttribute('y', '0')
//           zoomOutBackground.setAttribute('width', '1500') // larger than expected because the whole group is transformed to scale down
//           zoomOutBackground.setAttribute('height', '1400')
//           zoomOutBackground.setAttribute('class', 'svg-pan-zoom-control-background')
//           zoomOut.appendChild(zoomOutBackground)

//           var zoomOutShape = document.createElementNS(SvgUtils.svgNS, 'path')
//           zoomOutShape.setAttribute('d', 'M1280 576v128q0 26 -19 45t-45 19h-896q-26 0 -45 -19t-19 -45v-128q0 -26 19 -45t45 -19h896q26 0 45 19t19 45zM1536 1120v-960q0 -119 -84.5 -203.5t-203.5 -84.5h-960q-119 0 -203.5 84.5t-84.5 203.5v960q0 119 84.5 203.5t203.5 84.5h960q119 0 203.5 -84.5 t84.5 -203.5z')
//           zoomOutShape.setAttribute('class', 'svg-pan-zoom-control-element')
//           zoomOut.appendChild(zoomOutShape)

//           return zoomOut
//         },

//         disable: function (instance) {
//           if (instance.controlIcons) {
//             instance.controlIcons.parentNode.removeChild(instance.controlIcons)
//             instance.controlIcons = null
//           }
//         }
//       }
//       /** */ },

//     /** */ './node_modules/svg-pan-zoom/src/shadow-viewport.js':
//     /*! **********************************************************!*\
//   !*** ./node_modules/svg-pan-zoom/src/shadow-viewport.js ***!
//   \**********************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       var SvgUtils = __webpack_require__(/*! ./svg-utilities */ './node_modules/svg-pan-zoom/src/svg-utilities.js')
//       var Utils = __webpack_require__(/*! ./utilities */ './node_modules/svg-pan-zoom/src/utilities.js')

//       var ShadowViewport = function (viewport, options) {
//         this.init(viewport, options)
//       }

//       /**
//  * Initialization
//  *
//  * @param  {SVGElement} viewport
//  * @param  {Object} options
//  */
//       ShadowViewport.prototype.init = function (viewport, options) {
//         // DOM Elements
//         this.viewport = viewport
//         this.options = options

//         // State cache
//         this.originalState = { zoom: 1, x: 0, y: 0 }
//         this.activeState = { zoom: 1, x: 0, y: 0 }

//         this.updateCTMCached = Utils.proxy(this.updateCTM, this)

//         // Create a custom requestAnimationFrame taking in account refreshRate
//         this.requestAnimationFrame = Utils.createRequestAnimationFrame(this.options.refreshRate)

//         // ViewBox
//         this.viewBox = { x: 0, y: 0, width: 0, height: 0 }
//         this.cacheViewBox()

//         // Process CTM
//         var newCTM = this.processCTM()

//         // Update viewport CTM and cache zoom and pan
//         this.setCTM(newCTM)

//         // Update CTM in this frame
//         this.updateCTM()
//       }

//       /**
//  * Cache initial viewBox value
//  * If no viewBox is defined, then use viewport size/position instead for viewBox values
//  */
//       ShadowViewport.prototype.cacheViewBox = function () {
//         var svgViewBox = this.options.svg.getAttribute('viewBox')

//         if (svgViewBox) {
//           var viewBoxValues = svgViewBox.split(/[\s\,]/).filter(function (v) { return v }).map(parseFloat)

//           // Cache viewbox x and y offset
//           this.viewBox.x = viewBoxValues[0]
//           this.viewBox.y = viewBoxValues[1]
//           this.viewBox.width = viewBoxValues[2]
//           this.viewBox.height = viewBoxValues[3]

//           var zoom = Math.min(this.options.width / this.viewBox.width, this.options.height / this.viewBox.height)

//           // Update active state
//           this.activeState.zoom = zoom
//           this.activeState.x = (this.options.width - this.viewBox.width * zoom) / 2
//           this.activeState.y = (this.options.height - this.viewBox.height * zoom) / 2

//           // Force updating CTM
//           this.updateCTMOnNextFrame()

//           this.options.svg.removeAttribute('viewBox')
//         } else {
//           this.simpleViewBoxCache()
//         }
//       }

//       /**
//  * Recalculate viewport sizes and update viewBox cache
//  */
//       ShadowViewport.prototype.simpleViewBoxCache = function () {
//         var bBox = this.viewport.getBBox()

//         this.viewBox.x = bBox.x
//         this.viewBox.y = bBox.y
//         this.viewBox.width = bBox.width
//         this.viewBox.height = bBox.height
//       }

//       /**
//  * Returns a viewbox object. Safe to alter
//  *
//  * @return {Object} viewbox object
//  */
//       ShadowViewport.prototype.getViewBox = function () {
//         return Utils.extend({}, this.viewBox)
//       }

//       /**
//  * Get initial zoom and pan values. Save them into originalState
//  * Parses viewBox attribute to alter initial sizes
//  *
//  * @return {CTM} CTM object based on options
//  */
//       ShadowViewport.prototype.processCTM = function () {
//         var newCTM = this.getCTM()

//         if (this.options.fit || this.options.contain) {
//           var newScale
//           if (this.options.fit) {
//             newScale = Math.min(this.options.width / this.viewBox.width, this.options.height / this.viewBox.height)
//           } else {
//             newScale = Math.max(this.options.width / this.viewBox.width, this.options.height / this.viewBox.height)
//           }
//           newScale = newScale * 0.85
//           newCTM.a = newScale // x-scale
//           newCTM.d = newScale // y-scale
//           newCTM.e = -this.viewBox.x * newScale // x-transform
//           newCTM.f = -this.viewBox.y * newScale // y-transform
//         }

//         if (this.options.center) {
//           var offsetX = (this.options.width - (this.viewBox.width + this.viewBox.x * 2) * newCTM.a) * 0.2
//           var offsetY = (this.options.height - (this.viewBox.height + this.viewBox.y * 2) * newCTM.a) * 0.5

//           newCTM.e = offsetX
//           newCTM.f = offsetY
//         }

//         // Cache initial values. Based on activeState and fix+center opitons
//         this.originalState.zoom = newCTM.a
//         this.originalState.x = newCTM.e
//         this.originalState.y = newCTM.f

//         return newCTM
//       }

//       /**
//  * Return originalState object. Safe to alter
//  *
//  * @return {Object}
//  */
//       ShadowViewport.prototype.getOriginalState = function () {
//         return Utils.extend({}, this.originalState)
//       }

//       /**
//  * Return actualState object. Safe to alter
//  *
//  * @return {Object}
//  */
//       ShadowViewport.prototype.getState = function () {
//         return Utils.extend({}, this.activeState)
//       }

//       /**
//  * Get zoom scale
//  *
//  * @return {Float} zoom scale
//  */
//       ShadowViewport.prototype.getZoom = function () {
//         return this.activeState.zoom
//       }

//       /**
//  * Get zoom scale for pubilc usage
//  *
//  * @return {Float} zoom scale
//  */
//       ShadowViewport.prototype.getRelativeZoom = function () {
//         return this.activeState.zoom / this.originalState.zoom
//       }

//       /**
//  * Compute zoom scale for pubilc usage
//  *
//  * @return {Float} zoom scale
//  */
//       ShadowViewport.prototype.computeRelativeZoom = function (scale) {
//         return scale / this.originalState.zoom
//       }

//       /**
//  * Get pan
//  *
//  * @return {Object}
//  */
//       ShadowViewport.prototype.getPan = function () {
//         return { x: this.activeState.x, y: this.activeState.y }
//       }

//       /**
//  * Return cached viewport CTM value that can be safely modified
//  *
//  * @return {SVGMatrix}
//  */
//       ShadowViewport.prototype.getCTM = function () {
//         var safeCTM = this.options.svg.createSVGMatrix()

//         // Copy values manually as in FF they are not itterable
//         safeCTM.a = this.activeState.zoom
//         safeCTM.b = 0
//         safeCTM.c = 0
//         safeCTM.d = this.activeState.zoom
//         safeCTM.e = this.activeState.x
//         safeCTM.f = this.activeState.y

//         return safeCTM
//       }

//       /**
//  * Set a new CTM
//  *
//  * @param {SVGMatrix} newCTM
//  */
//       ShadowViewport.prototype.setCTM = function (newCTM) {
//         var willZoom = this.isZoomDifferent(newCTM)
//         var willPan = this.isPanDifferent(newCTM)

//         if (willZoom || willPan) {
//           // Before zoom
//           if (willZoom) {
//             // If returns false then cancel zooming
//             if (this.options.beforeZoom(this.getRelativeZoom(), this.computeRelativeZoom(newCTM.a)) === false) {
//               newCTM.a = newCTM.d = this.activeState.zoom
//               willZoom = false
//             } else {
//               this.updateCache(newCTM)
//               this.options.onZoom(this.getRelativeZoom())
//             }
//           }

//           // Before pan
//           if (willPan) {
//             var preventPan = this.options.beforePan(this.getPan(), { x: newCTM.e, y: newCTM.f })
//             // If prevent pan is an object
//             var preventPanX = false
//             var preventPanY = false

//             // If prevent pan is Boolean false
//             if (preventPan === false) {
//               // Set x and y same as before
//               newCTM.e = this.getPan().x
//               newCTM.f = this.getPan().y

//               preventPanX = preventPanY = true
//             } else if (Utils.isObject(preventPan)) {
//               // Check for X axes attribute
//               if (preventPan.x === false) {
//                 // Prevent panning on x axes
//                 newCTM.e = this.getPan().x
//                 preventPanX = true
//               } else if (Utils.isNumber(preventPan.x)) {
//                 // Set a custom pan value
//                 newCTM.e = preventPan.x
//               }

//               // Check for Y axes attribute
//               if (preventPan.y === false) {
//                 // Prevent panning on x axes
//                 newCTM.f = this.getPan().y
//                 preventPanY = true
//               } else if (Utils.isNumber(preventPan.y)) {
//                 // Set a custom pan value
//                 newCTM.f = preventPan.y
//               }
//             }

//             // Update willPan flag
//             // Check if newCTM is still different
//             if ((preventPanX && preventPanY) || !this.isPanDifferent(newCTM)) {
//               willPan = false
//             } else {
//               this.updateCache(newCTM)
//               this.options.onPan(this.getPan())
//             }
//           }

//           // Check again if should zoom or pan
//           if (willZoom || willPan) {
//             this.updateCTMOnNextFrame()
//           }
//         }
//       }

//       ShadowViewport.prototype.isZoomDifferent = function (newCTM) {
//         return this.activeState.zoom !== newCTM.a
//       }

//       ShadowViewport.prototype.isPanDifferent = function (newCTM) {
//         return this.activeState.x !== newCTM.e || this.activeState.y !== newCTM.f
//       }

//       /**
//  * Update cached CTM and active state
//  *
//  * @param {SVGMatrix} newCTM
//  */
//       ShadowViewport.prototype.updateCache = function (newCTM) {
//         this.activeState.zoom = newCTM.a
//         this.activeState.x = newCTM.e
//         this.activeState.y = newCTM.f
//       }

//       ShadowViewport.prototype.pendingUpdate = false

//       /**
//  * Place a request to update CTM on next Frame
//  */
//       ShadowViewport.prototype.updateCTMOnNextFrame = function () {
//         if (!this.pendingUpdate) {
//           // Lock
//           this.pendingUpdate = true

//           // Throttle next update
//           this.requestAnimationFrame.call(window, this.updateCTMCached)
//         }
//       }

//       /**
//  * Update viewport CTM with cached CTM
//  */
//       ShadowViewport.prototype.updateCTM = function () {
//         var ctm = this.getCTM()

//         // Updates SVG element
//         SvgUtils.setCTM(this.viewport, ctm, this.defs)

//         // Free the lock
//         this.pendingUpdate = false

//         // Notify about the update
//         if (this.options.onUpdatedCTM) {
//           this.options.onUpdatedCTM(ctm)
//         }
//       }

//       module.exports = function (viewport, options) {
//         return new ShadowViewport(viewport, options)
//       }
//       /** */ },

//     /** */ './node_modules/svg-pan-zoom/src/svg-pan-zoom.js':
//     /*! *******************************************************!*\
//   !*** ./node_modules/svg-pan-zoom/src/svg-pan-zoom.js ***!
//   \*******************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       var Wheel = __webpack_require__(/*! ./uniwheel */ './node_modules/svg-pan-zoom/src/uniwheel.js')
//       var ControlIcons = __webpack_require__(/*! ./control-icons */ './node_modules/svg-pan-zoom/src/control-icons.js')
//       var Utils = __webpack_require__(/*! ./utilities */ './node_modules/svg-pan-zoom/src/utilities.js')
//       var SvgUtils = __webpack_require__(/*! ./svg-utilities */ './node_modules/svg-pan-zoom/src/svg-utilities.js')
//       var ShadowViewport = __webpack_require__(/*! ./shadow-viewport */ './node_modules/svg-pan-zoom/src/shadow-viewport.js')

//       var SvgPanZoom = function (svg, options) {
//         this.init(svg, options)
//       }

//       var optionsDefaults = {
//         viewportSelector: '.svg-pan-zoom_viewport', // Viewport selector. Can be querySelector string or SVGElement
//         panEnabled: true, // enable or disable panning (default enabled)
//         controlIconsEnabled: false, // insert icons to give user an option in addition to mouse events to control pan/zoom (default disabled)
//         zoomEnabled: true, // enable or disable zooming (default enabled)
//         dblClickZoomEnabled: true, // enable or disable zooming by double clicking (default enabled)
//         mouseWheelZoomEnabled: true, // enable or disable zooming by mouse wheel (default enabled)
//         preventMouseEventsDefault: true, // enable or disable preventDefault for mouse events
//         zoomScaleSensitivity: 0.1, // Zoom sensitivity
//         minZoom: 0.5, // Minimum Zoom level
//         maxZoom: 10, // Maximum Zoom level
//         fit: true, // enable or disable viewport fit in SVG (default true)
//         contain: false, // enable or disable viewport contain the svg (default false)
//         center: true, // enable or disable viewport centering in SVG (default true)
//         refreshRate: 'auto', // Maximum number of frames per second (altering SVG's viewport)
//         beforeZoom: null,
//         onZoom: null,
//         beforePan: null,
//         onPan: null,
//         customEventsHandler: null,
//         eventsListenerElement: null,
//         onUpdatedCTM: null
//       }

//       var passiveListenerOption = { passive: true }

//       SvgPanZoom.prototype.init = function (svg, options) {
//         var that = this

//         this.svg = svg
//         this.defs = svg.querySelector('defs')

//         // Add default attributes to SVG
//         SvgUtils.setupSvgAttributes(this.svg)

//         // Set options
//         this.options = Utils.extend(Utils.extend({}, optionsDefaults), options)

//         // Set default state
//         this.state = 'none'

//         // Get dimensions
//         var boundingClientRectNormalized = SvgUtils.getBoundingClientRectNormalized(svg)
//         this.width = boundingClientRectNormalized.width
//         this.height = boundingClientRectNormalized.height

//         // Init shadow viewport
//         this.viewport = ShadowViewport(SvgUtils.getOrCreateViewport(this.svg, this.options.viewportSelector), {
//           svg: this.svg,
//           width: this.width,
//           height: this.height,
//           fit: this.options.fit,
//           contain: this.options.contain,
//           center: this.options.center,
//           refreshRate: this.options.refreshRate,
//           // Put callbacks into functions as they can change through time
//           beforeZoom: function (oldScale, newScale) {
//             if (that.viewport && that.options.beforeZoom) { return that.options.beforeZoom(oldScale, newScale) }
//           },
//           onZoom: function (scale) {
//             if (that.viewport && that.options.onZoom) { return that.options.onZoom(scale) }
//           },
//           beforePan: function (oldPoint, newPoint) {
//             if (that.viewport && that.options.beforePan) { return that.options.beforePan(oldPoint, newPoint) }
//           },
//           onPan: function (point) {
//             if (that.viewport && that.options.onPan) { return that.options.onPan(point) }
//           },
//           onUpdatedCTM: function (ctm) {
//             if (that.viewport && that.options.onUpdatedCTM) { return that.options.onUpdatedCTM(ctm) }
//           }
//         })

//         // Wrap callbacks into public API context
//         var publicInstance = this.getPublicInstance()
//         publicInstance.setBeforeZoom(this.options.beforeZoom)
//         publicInstance.setOnZoom(this.options.onZoom)
//         publicInstance.setBeforePan(this.options.beforePan)
//         publicInstance.setOnPan(this.options.onPan)
//         publicInstance.setOnUpdatedCTM(this.options.onUpdatedCTM)

//         if (this.options.controlIconsEnabled) {
//           ControlIcons.enable(this)
//         }

//         // Init events handlers
//         this.lastMouseWheelEventTime = Date.now()
//         this.setupHandlers()
//       }

//       /**
//  * Register event handlers
//  */
//       SvgPanZoom.prototype.setupHandlers = function () {
//         var that = this
//         var prevEvt = null // use for touchstart event to detect double tap

//         this.eventListeners = {
//           // Mouse down group
//           mousedown: function (evt) {
//             if (evt.button === 2) {
//               var point = SvgUtils.getEventPoint1(evt, that.svg).matrixTransform(that.viewport.getCTM().inverse())
//               that.options.onRegionChange(point, 'mousedown')
//               return false
//             }
//             var result = that.handleMouseDown(evt, prevEvt)
//             prevEvt = evt
//             return result
//           },
//           touchstart: function (evt) {
//             var result = that.handleMouseDown(evt, prevEvt)
//             prevEvt = evt
//             return result
//           },

//           // Mouse up group
//           mouseup: function (evt) {
//             var point = SvgUtils.getEventPoint1(evt, that.svg).matrixTransform(that.viewport.getCTM().inverse())

//             that.options.onRegionChange(point, 'mouseup')
//             return that.handleMouseUp(evt)
//           },
//           touchend: function (evt) {
//             return that.handleMouseUp(evt)
//           },

//           // Mouse move group
//           mousemove: function (evt) {
//             var point = SvgUtils.getEventPoint1(evt, that.svg).matrixTransform(that.viewport.getCTM().inverse())
//             that.options.onRegionChange(point, 'mousemove')

//             return that.handleMouseMove(evt)
//           },
//           touchmove: function (evt) {
//             return that.handleMouseMove(evt)
//           },

//           // Mouse leave group
//           mouseleave: function (evt) {
//             return that.handleMouseUp(evt)
//           },
//           touchleave: function (evt) {
//             return that.handleMouseUp(evt)
//           },
//           touchcancel: function (evt) {
//             return that.handleMouseUp(evt)
//           }
//         }

//         // Init custom events handler if available
//         if (this.options.customEventsHandler != null) { // jshint ignore:line
//           this.options.customEventsHandler.init({
//             svgElement: this.svg,
//             eventsListenerElement: this.options.eventsListenerElement,
//             instance: this.getPublicInstance()
//           })

//           // Custom event handler may halt builtin listeners
//           var haltEventListeners = this.options.customEventsHandler.haltEventListeners
//           if (haltEventListeners && haltEventListeners.length) {
//             for (var i = haltEventListeners.length - 1; i >= 0; i--) {
//               if (this.eventListeners.hasOwnProperty(haltEventListeners[i])) {
//                 delete this.eventListeners[haltEventListeners[i]]
//               }
//             }
//           }
//         }

//         // Bind eventListeners
//         for (var event in this.eventListeners) {
//           // Attach event to eventsListenerElement or SVG if not available
//           (this.options.eventsListenerElement || this.svg)
//             .addEventListener(event, this.eventListeners[event], !this.options.preventMouseEventsDefault ? passiveListenerOption : false)
//         }

//         // Zoom using mouse wheel
//         if (this.options.mouseWheelZoomEnabled) {
//           this.options.mouseWheelZoomEnabled = false // set to false as enable will set it back to true
//           this.enableMouseWheelZoom()
//         }
//       }

//       /**
//  * Enable ability to zoom using mouse wheel
//  */
//       SvgPanZoom.prototype.enableMouseWheelZoom = function () {
//         if (!this.options.mouseWheelZoomEnabled) {
//           var that = this

//           // Mouse wheel listener
//           this.wheelListener = function (evt) {
//             return that.handleMouseWheel(evt)
//           }

//           // Bind wheelListener
//           var isPassiveListener = !this.options.preventMouseEventsDefault
//           Wheel.on(this.options.eventsListenerElement || this.svg, this.wheelListener, isPassiveListener)

//           this.options.mouseWheelZoomEnabled = true
//         }
//       }

//       /**
//  * Disable ability to zoom using mouse wheel
//  */
//       SvgPanZoom.prototype.disableMouseWheelZoom = function () {
//         if (this.options.mouseWheelZoomEnabled) {
//           var isPassiveListener = !this.options.preventMouseEventsDefault
//           Wheel.off(this.options.eventsListenerElement || this.svg, this.wheelListener, isPassiveListener)
//           this.options.mouseWheelZoomEnabled = false
//         }
//       }

//       /**
//  * Handle mouse wheel event
//  *
//  * @param  {Event} evt
//  */
//       SvgPanZoom.prototype.handleMouseWheel = function (evt) {
//         if (!this.options.zoomEnabled || this.state !== 'none') {
//           return
//         }

//         if (this.options.preventMouseEventsDefault) {
//           if (evt.preventDefault) {
//             evt.preventDefault()
//           } else {
//             evt.returnValue = false
//           }
//         }

//         // Default delta in case that deltaY is not available
//         var delta = evt.deltaY || 1
//         var timeDelta = Date.now() - this.lastMouseWheelEventTime
//         var divider = 3 + Math.max(0, 30 - timeDelta)

//         // Update cache
//         this.lastMouseWheelEventTime = Date.now()

//         // Make empirical adjustments for browsers that give deltaY in pixels (deltaMode=0)
//         if ('deltaMode' in evt && evt.deltaMode === 0 && evt.wheelDelta) {
//           delta = evt.deltaY === 0 ? 0 : Math.abs(evt.wheelDelta) / evt.deltaY
//         }

//         delta = delta > -0.3 && delta < 0.3 ? delta : (delta > 0 ? 1 : -1) * Math.log(Math.abs(delta) + 10) / divider

//         var inversedScreenCTM = this.svg.getScreenCTM().inverse()
//         var relativeMousePoint = SvgUtils.getEventPoint(evt, this.svg).matrixTransform(inversedScreenCTM)
//         var zoom = Math.pow(1 + this.options.zoomScaleSensitivity, (-1) * delta) // multiplying by neg. 1 so as to make zoom in/out behavior match Google maps behavior

//         this.zoomAtPoint(zoom, relativeMousePoint)
//       }

//       /**
//  * Zoom in at a SVG point
//  *
//  * @param  {SVGPoint} point
//  * @param  {Float} zoomScale    Number representing how much to zoom
//  * @param  {Boolean} zoomAbsolute Default false. If true, zoomScale is treated as an absolute value.
//  *                                Otherwise, zoomScale is treated as a multiplied (e.g. 1.10 would zoom in 10%)
//  */
//       SvgPanZoom.prototype.zoomAtPoint = function (zoomScale, point, zoomAbsolute) {
//         var originalState = this.viewport.getOriginalState()

//         if (!zoomAbsolute) {
//           // Fit zoomScale in set bounds
//           if (this.getZoom() * zoomScale < this.options.minZoom * originalState.zoom) {
//             zoomScale = (this.options.minZoom * originalState.zoom) / this.getZoom()
//           } else if (this.getZoom() * zoomScale > this.options.maxZoom * originalState.zoom) {
//             zoomScale = (this.options.maxZoom * originalState.zoom) / this.getZoom()
//           }
//         } else {
//           // Fit zoomScale in set bounds
//           zoomScale = Math.max(this.options.minZoom * originalState.zoom, Math.min(this.options.maxZoom * originalState.zoom, zoomScale))
//           // Find relative scale to achieve desired scale
//           zoomScale = zoomScale / this.getZoom()
//         }

//         var oldCTM = this.viewport.getCTM()
//         var relativePoint = point.matrixTransform(oldCTM.inverse())
//         var modifier = this.svg.createSVGMatrix().translate(relativePoint.x, relativePoint.y).scale(zoomScale).translate(-relativePoint.x, -relativePoint.y)
//         var newCTM = oldCTM.multiply(modifier)

//         if (newCTM.a !== oldCTM.a) {
//           this.viewport.setCTM(newCTM)
//         }
//       }

//       /**
//  * Zoom at center point
//  *
//  * @param  {Float} scale
//  * @param  {Boolean} absolute Marks zoom scale as relative or absolute
//  */
//       SvgPanZoom.prototype.zoom = function (scale, absolute) {
//         this.zoomAtPoint(scale, SvgUtils.getSvgCenterPoint(this.svg, this.width, this.height), absolute)
//       }

//       /**
//  * Zoom used by public instance
//  *
//  * @param  {Float} scale
//  * @param  {Boolean} absolute Marks zoom scale as relative or absolute
//  */
//       SvgPanZoom.prototype.publicZoom = function (scale, absolute) {
//         if (absolute) {
//           scale = this.computeFromRelativeZoom(scale)
//         }

//         this.zoom(scale, absolute)
//       }

//       /**
//  * Zoom at point used by public instance
//  *
//  * @param  {Float} scale
//  * @param  {SVGPoint|Object} point    An object that has x and y attributes
//  * @param  {Boolean} absolute Marks zoom scale as relative or absolute
//  */
//       SvgPanZoom.prototype.publicZoomAtPoint = function (scale, point, absolute) {
//         if (absolute) {
//           // Transform zoom into a relative value
//           scale = this.computeFromRelativeZoom(scale)
//         }

//         // If not a SVGPoint but has x and y then create a SVGPoint
//         if (Utils.getType(point) !== 'SVGPoint') {
//           if ('x' in point && 'y' in point) {
//             point = SvgUtils.createSVGPoint(this.svg, point.x, point.y)
//           } else {
//             throw new Error('Given point is invalid')
//           }
//         }

//         this.zoomAtPoint(scale, point, absolute)
//       }

//       /**
//  * Get zoom scale
//  *
//  * @return {Float} zoom scale
//  */
//       SvgPanZoom.prototype.getZoom = function () {
//         return this.viewport.getZoom()
//       }

//       /**
//  * Get zoom scale for public usage
//  *
//  * @return {Float} zoom scale
//  */
//       SvgPanZoom.prototype.getRelativeZoom = function () {
//         return this.viewport.getRelativeZoom()
//       }

//       /**
//  * Compute actual zoom from public zoom
//  *
//  * @param  {Float} zoom
//  * @return {Float} zoom scale
//  */
//       SvgPanZoom.prototype.computeFromRelativeZoom = function (zoom) {
//         return zoom * this.viewport.getOriginalState().zoom
//       }

//       /**
//  * Set zoom to initial state
//  */
//       SvgPanZoom.prototype.resetZoom = function () {
//         var originalState = this.viewport.getOriginalState()

//         this.zoom(originalState.zoom, true)
//       }

//       /**
//  * Set pan to initial state
//  */
//       SvgPanZoom.prototype.resetPan = function () {
//         this.pan(this.viewport.getOriginalState())
//       }

//       /**
//  * Set pan and zoom to initial state
//  */
//       SvgPanZoom.prototype.reset = function () {
//         this.resetZoom()
//         this.resetPan()
//       }

//       /**
//  * Handle double click event
//  * See handleMouseDown() for alternate detection method
//  *
//  * @param {Event} evt
//  */
//       SvgPanZoom.prototype.handleDblClick = function (evt) {
//         if (this.options.preventMouseEventsDefault) {
//           if (evt.preventDefault) {
//             evt.preventDefault()
//           } else {
//             evt.returnValue = false
//           }
//         }

//         // Check if target was a control button
//         if (this.options.controlIconsEnabled) {
//           var targetClass = evt.target.getAttribute('class') || ''
//           if (targetClass.indexOf('svg-pan-zoom-control') > -1) {
//             return false
//           }
//         }

//         var zoomFactor

//         if (evt.shiftKey) {
//           zoomFactor = 1 / ((1 + this.options.zoomScaleSensitivity) * 2) // zoom out when shift key pressed
//         } else {
//           zoomFactor = (1 + this.options.zoomScaleSensitivity) * 2
//         }

//         var point = SvgUtils.getEventPoint(evt, this.svg).matrixTransform(this.svg.getScreenCTM().inverse())
//         this.zoomAtPoint(zoomFactor, point)
//       }

//       /**
//  * Handle click event
//  *
//  * @param {Event} evt
//  */
//       SvgPanZoom.prototype.handleMouseDown = function (evt, prevEvt) {
//         if (this.options.preventMouseEventsDefault) {
//           if (evt.preventDefault) {
//             evt.preventDefault()
//           } else {
//             evt.returnValue = false
//           }
//         }

//         Utils.mouseAndTouchNormalize(evt, this.svg)

//         // Double click detection; more consistent than ondblclick
//         if (this.options.dblClickZoomEnabled && Utils.isDblClick(evt, prevEvt)) {
//           this.handleDblClick(evt)
//         } else {
//           // Pan mode
//           this.state = 'pan'
//           this.firstEventCTM = this.viewport.getCTM()
//           this.stateOrigin = SvgUtils.getEventPoint(evt, this.svg).matrixTransform(this.firstEventCTM.inverse())
//         }
//       }

//       /**
//  * Handle mouse move event
//  *
//  * @param  {Event} evt
//  */
//       SvgPanZoom.prototype.handleMouseMove = function (evt) {
//         if (this.options.preventMouseEventsDefault) {
//           if (evt.preventDefault) {
//             evt.preventDefault()
//           } else {
//             evt.returnValue = false
//           }
//         }

//         if (this.state === 'pan' && this.options.panEnabled) {
//           // Pan mode
//           var point = SvgUtils.getEventPoint(evt, this.svg).matrixTransform(this.firstEventCTM.inverse())
//           var viewportCTM = this.firstEventCTM.translate(point.x - this.stateOrigin.x, point.y - this.stateOrigin.y)

//           this.viewport.setCTM(viewportCTM)
//         }
//       }

//       /**
//  * Handle mouse button release event
//  *
//  * @param {Event} evt
//  */
//       SvgPanZoom.prototype.handleMouseUp = function (evt) {
//         if (this.options.preventMouseEventsDefault) {
//           if (evt.preventDefault) {
//             evt.preventDefault()
//           } else {
//             evt.returnValue = false
//           }
//         }

//         if (this.state === 'pan') {
//           // Quit pan mode
//           this.state = 'none'
//         }
//       }

//       /**
//  * Adjust viewport size (only) so it will fit in SVG
//  * Does not center image
//  */
//       SvgPanZoom.prototype.fit = function () {
//         var viewBox = this.viewport.getViewBox()
//         var newScale = Math.min(this.width / viewBox.width, this.height / viewBox.height)

//         this.zoom(newScale, true)
//       }

//       /**
//  * Adjust viewport size (only) so it will contain the SVG
//  * Does not center image
//  */
//       SvgPanZoom.prototype.contain = function () {
//         var viewBox = this.viewport.getViewBox()
//         var newScale = Math.max(this.width / viewBox.width, this.height / viewBox.height)

//         this.zoom(newScale, true)
//       }

//       /**
//  * Adjust viewport pan (only) so it will be centered in SVG
//  * Does not zoom/fit/contain image
//  */
//       SvgPanZoom.prototype.center = function () {
//         var viewBox = this.viewport.getViewBox()
//         var offsetX = (this.width - (viewBox.width + viewBox.x * 2) * this.getZoom()) * 0.5
//         var offsetY = (this.height - (viewBox.height + viewBox.y * 2) * this.getZoom()) * 0.5

//         this.getPublicInstance().pan({ x: offsetX, y: offsetY })
//       }

//       /**
//  * Update content cached BorderBox
//  * Use when viewport contents change
//  */
//       SvgPanZoom.prototype.updateBBox = function () {
//         this.viewport.simpleViewBoxCache()
//       }

//       /**
//  * Pan to a rendered position
//  *
//  * @param  {Object} point {x: 0, y: 0}
//  */
//       SvgPanZoom.prototype.pan = function (point) {
//         var viewportCTM = this.viewport.getCTM()
//         viewportCTM.e = point.x
//         viewportCTM.f = point.y
//         this.viewport.setCTM(viewportCTM)
//       }

//       /**
//  * Relatively pan the graph by a specified rendered position vector
//  *
//  * @param  {Object} point {x: 0, y: 0}
//  */
//       SvgPanZoom.prototype.panBy = function (point) {
//         var viewportCTM = this.viewport.getCTM()
//         viewportCTM.e += point.x
//         viewportCTM.f += point.y
//         this.viewport.setCTM(viewportCTM)
//       }

//       /**
//  * Get pan vector
//  *
//  * @return {Object} {x: 0, y: 0}
//  */
//       SvgPanZoom.prototype.getPan = function () {
//         var state = this.viewport.getState()

//         return { x: state.x, y: state.y }
//       }

//       /**
//  * Recalculates cached svg dimensions and controls position
//  */
//       SvgPanZoom.prototype.resize = function () {
//         // Get dimensions
//         var boundingClientRectNormalized = SvgUtils.getBoundingClientRectNormalized(this.svg)
//         this.width = boundingClientRectNormalized.width
//         this.height = boundingClientRectNormalized.height

//         // Recalculate original state
//         var viewport = this.viewport
//         viewport.options.width = this.width
//         viewport.options.height = this.height
//         viewport.processCTM()

//         // Reposition control icons by re-enabling them
//         if (this.options.controlIconsEnabled) {
//           this.getPublicInstance().disableControlIcons()
//           this.getPublicInstance().enableControlIcons()
//         }
//       }

//       /**
//  * Unbind mouse events, free callbacks and destroy public instance
//  */
//       SvgPanZoom.prototype.destroy = function () {
//         var that = this

//         // Free callbacks
//         this.beforeZoom = null
//         this.onZoom = null
//         this.beforePan = null
//         this.onPan = null
//         this.onUpdatedCTM = null

//         // Destroy custom event handlers
//         if (this.options.customEventsHandler != null) { // jshint ignore:line
//           this.options.customEventsHandler.destroy({
//             svgElement: this.svg,
//             eventsListenerElement: this.options.eventsListenerElement,
//             instance: this.getPublicInstance()
//           })
//         }

//         // Unbind eventListeners
//         for (var event in this.eventListeners) {
//           (this.options.eventsListenerElement || this.svg)
//             .removeEventListener(event, this.eventListeners[event], !this.options.preventMouseEventsDefault ? passiveListenerOption : false)
//         }

//         // Unbind wheelListener
//         this.disableMouseWheelZoom()

//         // Remove control icons
//         this.getPublicInstance().disableControlIcons()

//         // Reset zoom and pan
//         this.reset()

//         // Remove instance from instancesStore
//         instancesStore = instancesStore.filter(function (instance) {
//           return instance.svg !== that.svg
//         })

//         // Delete options and its contents
//         delete this.options

//         // Delete viewport to make public shadow viewport functions uncallable
//         delete this.viewport

//         // Destroy public instance and rewrite getPublicInstance
//         delete this.publicInstance
//         delete this.pi
//         this.getPublicInstance = function () {
//           return null
//         }
//       }

//       /**
//  * Returns a public instance object
//  *
//  * @return {Object} Public instance object
//  */
//       SvgPanZoom.prototype.getPublicInstance = function () {
//         var that = this

//         // Create cache
//         if (!this.publicInstance) {
//           this.publicInstance = this.pi = {
//             // Pan
//             enablePan: function () { that.options.panEnabled = true; return that.pi },
//             disablePan: function () { that.options.panEnabled = false; return that.pi },
//             isPanEnabled: function () { return !!that.options.panEnabled },
//             pan: function (point) { that.pan(point); return that.pi },
//             panBy: function (point) { that.panBy(point); return that.pi },
//             getPan: function () { return that.getPan() },
//             // Pan event
//             setBeforePan: function (fn) { that.options.beforePan = fn === null ? null : Utils.proxy(fn, that.publicInstance); return that.pi },
//             setOnPan: function (fn) { that.options.onPan = fn === null ? null : Utils.proxy(fn, that.publicInstance); return that.pi },
//             // Zoom and Control Icons
//             enableZoom: function () { that.options.zoomEnabled = true; return that.pi },
//             disableZoom: function () { that.options.zoomEnabled = false; return that.pi },
//             isZoomEnabled: function () { return !!that.options.zoomEnabled },
//             enableControlIcons: function () {
//               if (!that.options.controlIconsEnabled) {
//                 that.options.controlIconsEnabled = true
//                 ControlIcons.enable(that)
//               }
//               return that.pi
//             },
//             disableControlIcons: function () {
//               if (that.options.controlIconsEnabled) {
//                 that.options.controlIconsEnabled = false
//                 ControlIcons.disable(that)
//               }
//               return that.pi
//             },
//             isControlIconsEnabled: function () { return !!that.options.controlIconsEnabled },
//             // Double click zoom
//             enableDblClickZoom: function () { that.options.dblClickZoomEnabled = true; return that.pi },
//             disableDblClickZoom: function () { that.options.dblClickZoomEnabled = false; return that.pi },
//             isDblClickZoomEnabled: function () { return !!that.options.dblClickZoomEnabled },
//             // Mouse wheel zoom
//             enableMouseWheelZoom: function () { that.enableMouseWheelZoom(); return that.pi },
//             disableMouseWheelZoom: function () { that.disableMouseWheelZoom(); return that.pi },
//             isMouseWheelZoomEnabled: function () { return !!that.options.mouseWheelZoomEnabled },
//             // Zoom scale and bounds
//             setZoomScaleSensitivity: function (scale) { that.options.zoomScaleSensitivity = scale; return that.pi },
//             setMinZoom: function (zoom) { that.options.minZoom = zoom; return that.pi },
//             setMaxZoom: function (zoom) { that.options.maxZoom = zoom; return that.pi },
//             // Zoom event
//             setBeforeZoom: function (fn) { that.options.beforeZoom = fn === null ? null : Utils.proxy(fn, that.publicInstance); return that.pi },
//             setOnZoom: function (fn) { that.options.onZoom = fn === null ? null : Utils.proxy(fn, that.publicInstance); return that.pi },
//             // Zooming
//             zoom: function (scale) { that.publicZoom(scale, true); return that.pi },
//             zoomBy: function (scale) { that.publicZoom(scale, false); return that.pi },
//             zoomAtPoint: function (scale, point) { that.publicZoomAtPoint(scale, point, true); return that.pi },
//             zoomAtPointBy: function (scale, point) { that.publicZoomAtPoint(scale, point, false); return that.pi },
//             zoomIn: function () { this.zoomBy(1 + that.options.zoomScaleSensitivity); return that.pi },
//             zoomOut: function () { this.zoomBy(1 / (1 + that.options.zoomScaleSensitivity)); return that.pi },
//             getZoom: function () { return that.getRelativeZoom() },
//             // CTM update
//             setOnUpdatedCTM: function (fn) { that.options.onUpdatedCTM = fn === null ? null : Utils.proxy(fn, that.publicInstance); return that.pi },
//             // Reset
//             resetZoom: function () { that.resetZoom(); return that.pi },
//             resetPan: function () { that.resetPan(); return that.pi },
//             reset: function () { that.reset(); return that.pi },
//             // Fit, Contain and Center
//             fit: function () { that.fit(); return that.pi },
//             contain: function () { that.contain(); return that.pi },
//             center: function () { that.center(); return that.pi },
//             // Size and Resize
//             updateBBox: function () { that.updateBBox(); return that.pi },
//             resize: function () { that.resize(); return that.pi },
//             getSizes: function () {
//               return {
//                 width: that.width,
//                 height: that.height,
//                 realZoom: that.getZoom(),
//                 viewBox: that.viewport.getViewBox()
//               }
//             },
//             // Destroy
//             destroy: function () { that.destroy(); return that.pi }
//           }
//         }

//         return this.publicInstance
//       }

//       /**
//  * Stores pairs of instances of SvgPanZoom and SVG
//  * Each pair is represented by an object {svg: SVGSVGElement, instance: SvgPanZoom}
//  *
//  * @type {Array}
//  */
//       var instancesStore = []

//       var svgPanZoom = function (elementOrSelector, options) {
//         var svg = Utils.getSvg(elementOrSelector)

//         if (svg === null) {
//           return null
//         } else {
//           // Look for existent instance
//           for (var i = instancesStore.length - 1; i >= 0; i--) {
//             if (instancesStore[i].svg === svg) {
//               return instancesStore[i].instance.getPublicInstance()
//             }
//           }

//           // If instance not found - create one
//           instancesStore.push({
//             svg: svg,
//             instance: new SvgPanZoom(svg, options)
//           })

//           // Return just pushed instance
//           return instancesStore[instancesStore.length - 1].instance.getPublicInstance()
//         }
//       }

//       module.exports = svgPanZoom
//       /** */ },

//     /** */ './node_modules/svg-pan-zoom/src/svg-utilities.js':
//     /*! ********************************************************!*\
//   !*** ./node_modules/svg-pan-zoom/src/svg-utilities.js ***!
//   \********************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       var Utils = __webpack_require__(/*! ./utilities */ './node_modules/svg-pan-zoom/src/utilities.js')
//       var _browser = 'unknown'

//       // http://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
//       if (/* @cc_on!@*/ false || !!document.documentMode) { // internet explorer
//         _browser = 'ie'
//       }

//       module.exports = {
//         svgNS: 'http://www.w3.org/2000/svg',
//         xmlNS: 'http://www.w3.org/XML/1998/namespace',
//         xmlnsNS: 'http://www.w3.org/2000/xmlns/',
//         xlinkNS: 'http://www.w3.org/1999/xlink',
//         evNS: 'http://www.w3.org/2001/xml-events',

//         /**
//    * Get svg dimensions: width and height
//    *
//    * @param  {SVGSVGElement} svg
//    * @return {Object}     {width: 0, height: 0}
//    */
//         getBoundingClientRectNormalized: function (svg) {
//           if (svg.clientWidth && svg.clientHeight) {
//             return { width: svg.clientWidth, height: svg.clientHeight }
//           } else if (svg.getBoundingClientRect()) {
//             return svg.getBoundingClientRect()
//           } else {
//             throw new Error('Cannot get BoundingClientRect for SVG.')
//           }
//         },

//         /**
//    * Gets g element with class of "viewport" or creates it if it doesn't exist
//    *
//    * @param  {SVGSVGElement} svg
//    * @return {SVGElement}     g (group) element
//    */
//         getOrCreateViewport: function (svg, selector) {
//           var viewport = null

//           if (Utils.isElement(selector)) {
//             viewport = selector
//           } else {
//             viewport = svg.querySelector(selector)
//           }

//           // Check if there is just one main group in SVG
//           if (!viewport) {
//             var childNodes = Array.prototype.slice.call(svg.childNodes || svg.children).filter(function (el) {
//               return el.nodeName !== 'defs' && el.nodeName !== '#text'
//             })

//             // Node name should be SVGGElement and should have no transform attribute
//             // Groups with transform are not used as viewport because it involves parsing of all transform possibilities
//             if (childNodes.length === 1 && childNodes[0].nodeName === 'g' && childNodes[0].getAttribute('transform') === null) {
//               viewport = childNodes[0]
//             }
//           }

//           // If no favorable group element exists then create one
//           if (!viewport) {
//             var viewportId = 'viewport-' + new Date().toISOString().replace(/\D/g, '')
//             viewport = document.createElementNS(this.svgNS, 'g')
//             viewport.setAttribute('id', viewportId)

//             // Internet Explorer (all versions?) can't use childNodes, but other browsers prefer (require?) using childNodes
//             var svgChildren = svg.childNodes || svg.children
//             if (!!svgChildren && svgChildren.length > 0) {
//               for (var i = svgChildren.length; i > 0; i--) {
//                 // Move everything into viewport except defs
//                 if (svgChildren[svgChildren.length - i].nodeName !== 'defs') {
//                   viewport.appendChild(svgChildren[svgChildren.length - i])
//                 }
//               }
//             }
//             svg.appendChild(viewport)
//           }

//           // Parse class names
//           var classNames = []
//           if (viewport.getAttribute('class')) {
//             classNames = viewport.getAttribute('class').split(' ')
//           }

//           // Set class (if not set already)
//           if (!~classNames.indexOf('svg-pan-zoom_viewport')) {
//             classNames.push('svg-pan-zoom_viewport')
//             viewport.setAttribute('class', classNames.join(' '))
//           }

//           return viewport
//         },

//         /**
//    * Set SVG attributes
//    *
//    * @param  {SVGSVGElement} svg
//    */
//         setupSvgAttributes: function (svg) {
//           // Setting default attributes
//           svg.setAttribute('xmlns', this.svgNS)
//           svg.setAttributeNS(this.xmlnsNS, 'xmlns:xlink', this.xlinkNS)
//           svg.setAttributeNS(this.xmlnsNS, 'xmlns:ev', this.evNS)

//           // Needed for Internet Explorer, otherwise the viewport overflows
//           if (svg.parentNode !== null) {
//             var style = svg.getAttribute('style') || ''
//             if (style.toLowerCase().indexOf('overflow') === -1) {
//               svg.setAttribute('style', 'overflow: hidden; ' + style)
//             }
//           }
//         },

//         /**
//  * How long Internet Explorer takes to finish updating its display (ms).
//  */
//         internetExplorerRedisplayInterval: 300,

//         /**
//  * Forces the browser to redisplay all SVG elements that rely on an
//  * element defined in a 'defs' section. It works globally, for every
//  * available defs element on the page.
//  * The throttling is intentionally global.
//  *
//  * This is only needed for IE. It is as a hack to make markers (and 'use' elements?)
//  * visible after pan/zoom when there are multiple SVGs on the page.
//  * See bug report: https://connect.microsoft.com/IE/feedback/details/781964/
//  * also see svg-pan-zoom issue: https://github.com/ariutta/svg-pan-zoom/issues/62
//  */
//         refreshDefsGlobal: Utils.throttle(function () {
//           var allDefs = document.querySelectorAll('defs')
//           var allDefsCount = allDefs.length
//           for (var i = 0; i < allDefsCount; i++) {
//             var thisDefs = allDefs[i]
//             thisDefs.parentNode.insertBefore(thisDefs, thisDefs)
//           }
//         }, this ? this.internetExplorerRedisplayInterval : null),

//         /**
//    * Sets the current transform matrix of an element
//    *
//    * @param {SVGElement} element
//    * @param {SVGMatrix} matrix  CTM
//    * @param {SVGElement} defs
//    */
//         setCTM: function (element, matrix, defs) {
//           var that = this
//           var s = 'matrix(' + matrix.a + ',' + matrix.b + ',' + matrix.c + ',' + matrix.d + ',' + matrix.e + ',' + matrix.f + ')'

//           element.setAttributeNS(null, 'transform', s)
//           if ('transform' in element.style) {
//             element.style.transform = s
//           } else if ('-ms-transform' in element.style) {
//             element.style['-ms-transform'] = s
//           } else if ('-webkit-transform' in element.style) {
//             element.style['-webkit-transform'] = s
//           }

//           // IE has a bug that makes markers disappear on zoom (when the matrix "a" and/or "d" elements change)
//           // see http://stackoverflow.com/questions/17654578/svg-marker-does-not-work-in-ie9-10
//           // and http://srndolha.wordpress.com/2013/11/25/svg-line-markers-may-disappear-in-internet-explorer-11/
//           if (_browser === 'ie' && !!defs) {
//             // this refresh is intended for redisplaying the SVG during zooming
//             defs.parentNode.insertBefore(defs, defs)
//             // this refresh is intended for redisplaying the other SVGs on a page when panning a given SVG
//             // it is also needed for the given SVG itself, on zoomEnd, if the SVG contains any markers that
//             // are located under any other element(s).
//             window.setTimeout(function () {
//               that.refreshDefsGlobal()
//             }, that.internetExplorerRedisplayInterval)
//           }
//         },

//         /**
//    * Instantiate an SVGPoint object with given event coordinates
//    *
//    * @param {Event} evt
//    * @param  {SVGSVGElement} svg
//    * @return {SVGPoint}     point
//    */
//         getEventPoint: function (evt, svg) {
//           var point = svg.createSVGPoint()

//           Utils.mouseAndTouchNormalize(evt, svg)

//           point.x = evt.clientX
//           point.y = evt.clientY

//           return point
//         },
//         getEventPoint1: function (evt, svg) {
//           var point = svg.createSVGPoint()

//           Utils.mouseAndTouchNormalize(evt, svg)

//           point.x = evt.offsetX
//           point.y = evt.offsetY

//           return point
//         },

//         /**
//    * Get SVG center point
//    *
//    * @param  {SVGSVGElement} svg
//    * @return {SVGPoint}
//    */
//         getSvgCenterPoint: function (svg, width, height) {
//           return this.createSVGPoint(svg, width / 2, height / 2)
//         },

//         /**
//    * Create a SVGPoint with given x and y
//    *
//    * @param  {SVGSVGElement} svg
//    * @param  {Number} x
//    * @param  {Number} y
//    * @return {SVGPoint}
//    */
//         createSVGPoint: function (svg, x, y) {
//           var point = svg.createSVGPoint()
//           point.x = x
//           point.y = y

//           return point
//         }
//       }
//       /** */ },

//     /** */ './node_modules/svg-pan-zoom/src/uniwheel.js':
//     /*! ***************************************************!*\
//   !*** ./node_modules/svg-pan-zoom/src/uniwheel.js ***!
//   \***************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports) {
//       // uniwheel 0.1.2 (customized)
//       // A unified cross browser mouse wheel event handler
//       // https://github.com/teemualap/uniwheel

//       module.exports = (function () {
//         // Full details: https://developer.mozilla.org/en-US/docs/Web/Reference/Events/wheel

//         var prefix = ''; var _addEventListener; var _removeEventListener; var support; var fns = []
//         var passiveOption = { passive: true }

//         // detect event model
//         if (window.addEventListener) {
//           _addEventListener = 'addEventListener'
//           _removeEventListener = 'removeEventListener'
//         } else {
//           _addEventListener = 'attachEvent'
//           _removeEventListener = 'detachEvent'
//           prefix = 'on'
//         }

//         // detect available wheel event
//         support = 'onwheel' in document.createElement('div') ? 'wheel' // Modern browsers support "wheel"
//           : document.onmousewheel !== undefined ? 'mousewheel' // Webkit and IE support at least "mousewheel"
//             : 'DOMMouseScroll' // let's assume that remaining browsers are older Firefox

//         function createCallback (element, callback) {
//           var fn = function (originalEvent) {
//             !originalEvent && (originalEvent = window.event)

//             // create a normalized event object
//             var event = {
//               // keep a ref to the original event object
//               originalEvent: originalEvent,
//               target: originalEvent.target || originalEvent.srcElement,
//               type: 'wheel',
//               deltaMode: originalEvent.type == 'MozMousePixelScroll' ? 0 : 1,
//               deltaX: 0,
//               delatZ: 0,
//               preventDefault: function () {
//                 originalEvent.preventDefault
//                   ? originalEvent.preventDefault()
//                   : originalEvent.returnValue = false
//               }
//             }

//             // calculate deltaY (and deltaX) according to the event
//             if (support == 'mousewheel') {
//               event.deltaY = -1 / 40 * originalEvent.wheelDelta
//               // Webkit also support wheelDeltaX
//               originalEvent.wheelDeltaX && (event.deltaX = -1 / 40 * originalEvent.wheelDeltaX)
//             } else {
//               event.deltaY = originalEvent.detail
//             }

//             // it's time to fire the callback
//             return callback(event)
//           }

//           fns.push({
//             element: element,
//             fn: fn
//           })

//           return fn
//         }

//         function getCallback (element) {
//           for (var i = 0; i < fns.length; i++) {
//             if (fns[i].element === element) {
//               return fns[i].fn
//             }
//           }
//           return function () {}
//         }

//         function removeCallback (element) {
//           for (var i = 0; i < fns.length; i++) {
//             if (fns[i].element === element) {
//               return fns.splice(i, 1)
//             }
//           }
//         }

//         function _addWheelListener (elem, eventName, callback, isPassiveListener) {
//           var cb

//           if (support === 'wheel') {
//             cb = callback
//           } else {
//             cb = createCallback(elem, callback)
//           }

//           elem[_addEventListener](prefix + eventName, cb, isPassiveListener ? passiveOption : false)
//         }

//         function _removeWheelListener (elem, eventName, callback, isPassiveListener) {
//           var cb

//           if (support === 'wheel') {
//             cb = callback
//           } else {
//             cb = getCallback(elem)
//           }

//           elem[_removeEventListener](prefix + eventName, cb, isPassiveListener ? passiveOption : false)

//           removeCallback(elem)
//         }

//         function addWheelListener (elem, callback, isPassiveListener) {
//           _addWheelListener(elem, support, callback, isPassiveListener)

//           // handle MozMousePixelScroll in older Firefox
//           if (support == 'DOMMouseScroll') {
//             _addWheelListener(elem, 'MozMousePixelScroll', callback, isPassiveListener)
//           }
//         }

//         function removeWheelListener (elem, callback, isPassiveListener) {
//           _removeWheelListener(elem, support, callback, isPassiveListener)

//           // handle MozMousePixelScroll in older Firefox
//           if (support == 'DOMMouseScroll') {
//             _removeWheelListener(elem, 'MozMousePixelScroll', callback, isPassiveListener)
//           }
//         }

//         return {
//           on: addWheelListener,
//           off: removeWheelListener
//         }
//       })()
//       /** */ },

//     /** */ './node_modules/svg-pan-zoom/src/utilities.js':
//     /*! ****************************************************!*\
//   !*** ./node_modules/svg-pan-zoom/src/utilities.js ***!
//   \****************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports) {
//       module.exports = {
//         /**
//    * Extends an object
//    *
//    * @param  {Object} target object to extend
//    * @param  {Object} source object to take properties from
//    * @return {Object}        extended object
//    */
//         extend: function (target, source) {
//           target = target || {}
//           for (var prop in source) {
//             // Go recursively
//             if (this.isObject(source[prop])) {
//               target[prop] = this.extend(target[prop], source[prop])
//             } else {
//               target[prop] = source[prop]
//             }
//           }
//           return target
//         },

//         /**
//    * Checks if an object is a DOM element
//    *
//    * @param  {Object}  o HTML element or String
//    * @return {Boolean}   returns true if object is a DOM element
//    */
//         isElement: function (o) {
//           return (
//             o instanceof HTMLElement || o instanceof SVGElement || o instanceof SVGSVGElement || // DOM2
//       (o && typeof o === 'object' && o !== null && o.nodeType === 1 && typeof o.nodeName === 'string')
//           )
//         },

//         /**
//    * Checks if an object is an Object
//    *
//    * @param  {Object}  o Object
//    * @return {Boolean}   returns true if object is an Object
//    */
//         isObject: function (o) {
//           return Object.prototype.toString.call(o) === '[object Object]'
//         },

//         /**
//    * Checks if variable is Number
//    *
//    * @param  {Integer|Float}  n
//    * @return {Boolean}   returns true if variable is Number
//    */
//         isNumber: function (n) {
//           return !isNaN(parseFloat(n)) && isFinite(n)
//         },

//         /**
//    * Search for an SVG element
//    *
//    * @param  {Object|String} elementOrSelector DOM Element or selector String
//    * @return {Object|Null}                   SVG or null
//    */
//         getSvg: function (elementOrSelector) {
//           var element,
//             svg

//           if (!this.isElement(elementOrSelector)) {
//             // If selector provided
//             if (typeof elementOrSelector === 'string' || elementOrSelector instanceof String) {
//               // Try to find the element
//               element = document.querySelector(elementOrSelector)

//               if (!element) {
//                 throw new Error('Provided selector did not find any elements. Selector: ' + elementOrSelector)
//                 return null
//               }
//             } else {
//               throw new Error('Provided selector is not an HTML object nor String')
//               return null
//             }
//           } else {
//             element = elementOrSelector
//           }

//           if (element.tagName.toLowerCase() === 'svg') {
//             svg = element
//           } else {
//             if (element.tagName.toLowerCase() === 'object') {
//               svg = element.contentDocument.documentElement
//             } else {
//               if (element.tagName.toLowerCase() === 'embed') {
//                 svg = element.getSVGDocument().documentElement
//               } else {
//                 if (element.tagName.toLowerCase() === 'img') {
//                   throw new Error('Cannot script an SVG in an "img" element. Please use an "object" element or an in-line SVG.')
//                 } else {
//                   throw new Error('Cannot get SVG.')
//                 }
//                 return null
//               }
//             }
//           }

//           return svg
//         },

//         /**
//    * Attach a given context to a function
//    * @param  {Function} fn      Function
//    * @param  {Object}   context Context
//    * @return {Function}           Function with certain context
//    */
//         proxy: function (fn, context) {
//           return function () {
//             return fn.apply(context, arguments)
//           }
//         },

//         /**
//    * Returns object type
//    * Uses toString that returns [object SVGPoint]
//    * And than parses object type from string
//    *
//    * @param  {Object} o Any object
//    * @return {String}   Object type
//    */
//         getType: function (o) {
//           return Object.prototype.toString.apply(o).replace(/^\[object\s/, '').replace(/\]$/, '')
//         },

//         /**
//    * If it is a touch event than add clientX and clientY to event object
//    *
//    * @param  {Event} evt
//    * @param  {SVGSVGElement} svg
//    */
//         mouseAndTouchNormalize: function (evt, svg) {
//           // If no clientX then fallback
//           if (evt.clientX === void 0 || evt.clientX === null) {
//             // Fallback
//             evt.clientX = 0
//             evt.clientY = 0

//             // If it is a touch event
//             if (evt.touches !== void 0 && evt.touches.length) {
//               if (evt.touches[0].clientX !== void 0) {
//                 evt.clientX = evt.touches[0].clientX
//                 evt.clientY = evt.touches[0].clientY
//               } else if (evt.touches[0].pageX !== void 0) {
//                 var rect = svg.getBoundingClientRect()

//                 evt.clientX = evt.touches[0].pageX - rect.left
//                 evt.clientY = evt.touches[0].pageY - rect.top
//               }
//               // If it is a custom event
//             } else if (evt.originalEvent !== void 0) {
//               if (evt.originalEvent.clientX !== void 0) {
//                 evt.clientX = evt.originalEvent.clientX
//                 evt.clientY = evt.originalEvent.clientY
//               }
//             }
//           }
//         },

//         /**
//    * Check if an event is a double click/tap
//    * TODO: For touch gestures use a library (hammer.js) that takes in account other events
//    * (touchmove and touchend). It should take in account tap duration and traveled distance
//    *
//    * @param  {Event}  evt
//    * @param  {Event}  prevEvt Previous Event
//    * @return {Boolean}
//    */
//         isDblClick: function (evt, prevEvt) {
//           // Double click detected by browser
//           if (evt.detail === 2) {
//             return true
//           }
//           // Try to compare events
//           else if (prevEvt !== void 0 && prevEvt !== null) {
//             var timeStampDiff = evt.timeStamp - prevEvt.timeStamp // should be lower than 250 ms
//             var touchesDistance = Math.sqrt(Math.pow(evt.clientX - prevEvt.clientX, 2) + Math.pow(evt.clientY - prevEvt.clientY, 2))

//             return timeStampDiff < 250 && touchesDistance < 10
//           }

//           // Nothing found
//           return false
//         },

//         /**
//    * Returns current timestamp as an integer
//    *
//    * @return {Number}
//    */
//         now: Date.now || function () {
//           return new Date().getTime()
//         },

//         // From underscore.
//         // Returns a function, that, when invoked, will only be triggered at most once
//         // during a given window of time. Normally, the throttled function will run
//         // as much as it can, without ever going more than once per `wait` duration;
//         // but if you'd like to disable the execution on the leading edge, pass
//         // `{leading: false}`. To disable execution on the trailing edge, ditto.
//         // jscs:disable
//         // jshint ignore:start
//         throttle: function (func, wait, options) {
//           var that = this
//           var context, args, result
//           var timeout = null
//           var previous = 0
//           if (!options) options = {}
//           var later = function () {
//             previous = options.leading === false ? 0 : that.now()
//             timeout = null
//             result = func.apply(context, args)
//             if (!timeout) context = args = null
//           }
//           return function () {
//             var now = that.now()
//             if (!previous && options.leading === false) previous = now
//             var remaining = wait - (now - previous)
//             context = this
//             args = arguments
//             if (remaining <= 0 || remaining > wait) {
//               clearTimeout(timeout)
//               timeout = null
//               previous = now
//               result = func.apply(context, args)
//               if (!timeout) context = args = null
//             } else if (!timeout && options.trailing !== false) {
//               timeout = setTimeout(later, remaining)
//             }
//             return result
//           }
//         },
//         // jshint ignore:end
//         // jscs:enable

//         /**
//    * Create a requestAnimationFrame simulation
//    *
//    * @param  {Number|String} refreshRate
//    * @return {Function}
//    */
//         createRequestAnimationFrame: function (refreshRate) {
//           var timeout = null

//           // Convert refreshRate to timeout
//           if (refreshRate !== 'auto' && refreshRate < 60 && refreshRate > 1) {
//             timeout = Math.floor(1000 / refreshRate)
//           }

//           if (timeout === null) {
//             return window.requestAnimationFrame || requestTimeout(33)
//           } else {
//             return requestTimeout(timeout)
//           }
//         }
//       }

//       /**
//  * Create a callback that will execute after a given timeout
//  *
//  * @param  {Function} timeout
//  * @return {Function}
//  */
//       function requestTimeout (timeout) {
//         return function (callback) {
//           window.setTimeout(callback, timeout)
//         }
//       }
//       /** */ },

//     /** */ './node_modules/timers-browserify/main.js':
//     /*! ************************************************!*\
//   !*** ./node_modules/timers-browserify/main.js ***!
//   \************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       /* WEBPACK VAR INJECTION */(function (global) {
//         var scope = (typeof global !== 'undefined' && global) ||
//             (typeof self !== 'undefined' && self) ||
//             window
//         var apply = Function.prototype.apply

//         // DOM APIs, for completeness

//         exports.setTimeout = function () {
//           return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout)
//         }
//         exports.setInterval = function () {
//           return new Timeout(apply.call(setInterval, scope, arguments), clearInterval)
//         }
//         exports.clearTimeout =
// exports.clearInterval = function (timeout) {
//   if (timeout) {
//     timeout.close()
//   }
// }

//         function Timeout (id, clearFn) {
//           this._id = id
//           this._clearFn = clearFn
//         }
//         Timeout.prototype.unref = Timeout.prototype.ref = function () {}
//         Timeout.prototype.close = function () {
//           this._clearFn.call(scope, this._id)
//         }

//         // Does not start the time, just sets up the members needed.
//         exports.enroll = function (item, msecs) {
//           clearTimeout(item._idleTimeoutId)
//           item._idleTimeout = msecs
//         }

//         exports.unenroll = function (item) {
//           clearTimeout(item._idleTimeoutId)
//           item._idleTimeout = -1
//         }

//         exports._unrefActive = exports.active = function (item) {
//           clearTimeout(item._idleTimeoutId)

//           var msecs = item._idleTimeout
//           if (msecs >= 0) {
//             item._idleTimeoutId = setTimeout(function onTimeout () {
//               if (item._onTimeout) { item._onTimeout() }
//             }, msecs)
//           }
//         }

//         // setimmediate attaches itself to the global object
//         __webpack_require__(/*! setimmediate */ './node_modules/setimmediate/setImmediate.js')
//         // On some exotic environments, it's not clear which object `setimmediate` was
//         // able to install onto.  Search each possibility in the same order as the
//         // `setimmediate` library.
//         exports.setImmediate = (typeof self !== 'undefined' && self.setImmediate) ||
//                        (typeof global !== 'undefined' && global.setImmediate) ||
//                        (this && this.setImmediate)
//         exports.clearImmediate = (typeof self !== 'undefined' && self.clearImmediate) ||
//                          (typeof global !== 'undefined' && global.clearImmediate) ||
//                          (this && this.clearImmediate)
//         /* WEBPACK VAR INJECTION */ }.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ './node_modules/webpack/buildin/global.js')))
//       /** */ },

//     /** */ './node_modules/vue-style-loader/index.js?!./node_modules/css-loader/index.js?!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css&':
//     /*! *****************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************!*\
//   !*** ./node_modules/vue-style-loader??ref--3-oneOf-1-0!./node_modules/css-loader??ref--3-oneOf-1-1!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js??ref--2-0!./node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./src/Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css& ***!
//   \*****************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       // style-loader: Adds some css to the DOM by adding a <style> tag

//       // load the styles
//       var content = __webpack_require__(/*! !../node_modules/css-loader??ref--3-oneOf-1-1!../node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!../node_modules/cache-loader/dist/cjs.js??ref--2-0!../node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css& */ './node_modules/css-loader/index.js?!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css&')
//       if (typeof content === 'string') content = [[module.i, content, '']]
//       if (content.locals) module.exports = content.locals
//       // add the styles to the DOM
//       var add = __webpack_require__(/*! ../node_modules/vue-style-loader/lib/addStylesClient.js */ './node_modules/vue-style-loader/lib/addStylesClient.js').default
//       var update = add('61cbfc00', content, false, { 'sourceMap': true })
//       // Hot Module Replacement
//       if (false) {}
//       /** */ },

//     /** */ './node_modules/vue-style-loader/index.js?!./node_modules/css-loader/index.js?!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css&':
//     /*! *******************************************************************************************************************************************************************************************************************************************************************************************************************************************************************!*\
//   !*** ./node_modules/vue-style-loader??ref--3-oneOf-1-0!./node_modules/css-loader??ref--3-oneOf-1-1!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js??ref--2-0!./node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./src/SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css& ***!
//   \*******************************************************************************************************************************************************************************************************************************************************************************************************************************************************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       // style-loader: Adds some css to the DOM by adding a <style> tag

//       // load the styles
//       var content = __webpack_require__(/*! !../node_modules/css-loader??ref--3-oneOf-1-1!../node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!../node_modules/cache-loader/dist/cjs.js??ref--2-0!../node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css& */ './node_modules/css-loader/index.js?!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css&')
//       if (typeof content === 'string') content = [[module.i, content, '']]
//       if (content.locals) module.exports = content.locals
//       // add the styles to the DOM
//       var add = __webpack_require__(/*! ../node_modules/vue-style-loader/lib/addStylesClient.js */ './node_modules/vue-style-loader/lib/addStylesClient.js').default
//       var update = add('0293d2b8', content, false, { 'sourceMap': true })
//       // Hot Module Replacement
//       if (false) {}
//       /** */ },

//     /** */ './node_modules/vue-style-loader/lib/addStylesClient.js':
//     /*! **************************************************************!*\
//   !*** ./node_modules/vue-style-loader/lib/addStylesClient.js ***!
//   \**************************************************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, 'default', function () { return addStylesClient })
//       /* harmony import */ var _listToStyles__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./listToStyles */ './node_modules/vue-style-loader/lib/listToStyles.js')
//       /*
//   MIT License http://www.opensource.org/licenses/mit-license.php
//   Author Tobias Koppers @sokra
//   Modified by Evan You @yyx990803
// */

//       var hasDocument = typeof document !== 'undefined'

//       if (typeof DEBUG !== 'undefined' && DEBUG) {
//         if (!hasDocument) {
//           throw new Error(
//             'vue-style-loader cannot be used in a non-browser environment. ' +
//     'Use { target: \'node\' } in your Webpack config to indicate a server-rendering environment.'
//           )
//         }
//       }

//       /*
// type StyleObject = {
//   id: number;
//   parts: Array<StyleObjectPart>
// }

// type StyleObjectPart = {
//   css: string;
//   media: string;
//   sourceMap: ?string
// }
// */

//       var stylesInDom = {/*
//   [id: number]: {
//     id: number,
//     refs: number,
//     parts: Array<(obj?: StyleObjectPart) => void>
//   }
// */}

//       var head = hasDocument && (document.head || document.getElementsByTagName('head')[0])
//       var singletonElement = null
//       var singletonCounter = 0
//       var isProduction = false
//       var noop = function () {}
//       var options = null
//       var ssrIdKey = 'data-vue-ssr-id'

//       // Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
//       // tags it will allow on a page
//       var isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\b/.test(navigator.userAgent.toLowerCase())

//       function addStylesClient (parentId, list, _isProduction, _options) {
//         isProduction = _isProduction

//         options = _options || {}

//         var styles = Object(_listToStyles__WEBPACK_IMPORTED_MODULE_0__['default'])(parentId, list)
//         addStylesToDom(styles)

//         return function update (newList) {
//           var mayRemove = []
//           for (var i = 0; i < styles.length; i++) {
//             var item = styles[i]
//             var domStyle = stylesInDom[item.id]
//             domStyle.refs--
//             mayRemove.push(domStyle)
//           }
//           if (newList) {
//             styles = Object(_listToStyles__WEBPACK_IMPORTED_MODULE_0__['default'])(parentId, newList)
//             addStylesToDom(styles)
//           } else {
//             styles = []
//           }
//           for (var i = 0; i < mayRemove.length; i++) {
//             var domStyle = mayRemove[i]
//             if (domStyle.refs === 0) {
//               for (var j = 0; j < domStyle.parts.length; j++) {
//                 domStyle.parts[j]()
//               }
//               delete stylesInDom[domStyle.id]
//             }
//           }
//         }
//       }

//       function addStylesToDom (styles /* Array<StyleObject> */) {
//         for (var i = 0; i < styles.length; i++) {
//           var item = styles[i]
//           var domStyle = stylesInDom[item.id]
//           if (domStyle) {
//             domStyle.refs++
//             for (var j = 0; j < domStyle.parts.length; j++) {
//               domStyle.parts[j](item.parts[j])
//             }
//             for (; j < item.parts.length; j++) {
//               domStyle.parts.push(addStyle(item.parts[j]))
//             }
//             if (domStyle.parts.length > item.parts.length) {
//               domStyle.parts.length = item.parts.length
//             }
//           } else {
//             var parts = []
//             for (var j = 0; j < item.parts.length; j++) {
//               parts.push(addStyle(item.parts[j]))
//             }
//             stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts }
//           }
//         }
//       }

//       function createStyleElement () {
//         var styleElement = document.createElement('style')
//         styleElement.type = 'text/css'
//         head.appendChild(styleElement)
//         return styleElement
//       }

//       function addStyle (obj /* StyleObjectPart */) {
//         var update, remove
//         var styleElement = document.querySelector('style[' + ssrIdKey + '~="' + obj.id + '"]')

//         if (styleElement) {
//           if (isProduction) {
//             // has SSR styles and in production mode.
//             // simply do nothing.
//             return noop
//           } else {
//             // has SSR styles but in dev mode.
//             // for some reason Chrome can't handle source map in server-rendered
//             // style tags - source maps in <style> only works if the style tag is
//             // created and inserted dynamically. So we remove the server rendered
//             // styles and inject new ones.
//             styleElement.parentNode.removeChild(styleElement)
//           }
//         }

//         if (isOldIE) {
//           // use singleton mode for IE9.
//           var styleIndex = singletonCounter++
//           styleElement = singletonElement || (singletonElement = createStyleElement())
//           update = applyToSingletonTag.bind(null, styleElement, styleIndex, false)
//           remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true)
//         } else {
//           // use multi-style-tag mode in all other cases
//           styleElement = createStyleElement()
//           update = applyToTag.bind(null, styleElement)
//           remove = function () {
//             styleElement.parentNode.removeChild(styleElement)
//           }
//         }

//         update(obj)

//         return function updateStyle (newObj /* StyleObjectPart */) {
//           if (newObj) {
//             if (newObj.css === obj.css &&
//           newObj.media === obj.media &&
//           newObj.sourceMap === obj.sourceMap) {
//               return
//             }
//             update(obj = newObj)
//           } else {
//             remove()
//           }
//         }
//       }

//       var replaceText = (function () {
//         var textStore = []

//         return function (index, replacement) {
//           textStore[index] = replacement
//           return textStore.filter(Boolean).join('\n')
//         }
//       })()

//       function applyToSingletonTag (styleElement, index, remove, obj) {
//         var css = remove ? '' : obj.css

//         if (styleElement.styleSheet) {
//           styleElement.styleSheet.cssText = replaceText(index, css)
//         } else {
//           var cssNode = document.createTextNode(css)
//           var childNodes = styleElement.childNodes
//           if (childNodes[index]) styleElement.removeChild(childNodes[index])
//           if (childNodes.length) {
//             styleElement.insertBefore(cssNode, childNodes[index])
//           } else {
//             styleElement.appendChild(cssNode)
//           }
//         }
//       }

//       function applyToTag (styleElement, obj) {
//         var css = obj.css
//         var media = obj.media
//         var sourceMap = obj.sourceMap

//         if (media) {
//           styleElement.setAttribute('media', media)
//         }
//         if (options.ssrId) {
//           styleElement.setAttribute(ssrIdKey, obj.id)
//         }

//         if (sourceMap) {
//           // https://developer.chrome.com/devtools/docs/javascript-debugging
//           // this makes source maps inside style tags work properly in Chrome
//           css += '\n/*# sourceURL=' + sourceMap.sources[0] + ' */'
//           // http://stackoverflow.com/a/26603875
//           css += '\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */'
//         }

//         if (styleElement.styleSheet) {
//           styleElement.styleSheet.cssText = css
//         } else {
//           while (styleElement.firstChild) {
//             styleElement.removeChild(styleElement.firstChild)
//           }
//           styleElement.appendChild(document.createTextNode(css))
//         }
//       }
//       /** */ },

//     /** */ './node_modules/vue-style-loader/lib/listToStyles.js':
//     /*! ***********************************************************!*\
//   !*** ./node_modules/vue-style-loader/lib/listToStyles.js ***!
//   \***********************************************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, 'default', function () { return listToStyles })
//       /**
//  * Translates the list format produced by css-loader into something
//  * easier to manipulate.
//  */
//       function listToStyles (parentId, list) {
//         var styles = []
//         var newStyles = {}
//         for (var i = 0; i < list.length; i++) {
//           var item = list[i]
//           var id = item[0]
//           var css = item[1]
//           var media = item[2]
//           var sourceMap = item[3]
//           var part = {
//             id: parentId + ':' + i,
//             css: css,
//             media: media,
//             sourceMap: sourceMap
//           }
//           if (!newStyles[id]) {
//             styles.push(newStyles[id] = { id: id, parts: [part] })
//           } else {
//             newStyles[id].parts.push(part)
//           }
//         }
//         return styles
//       }
//       /** */ },

//     /** */ './node_modules/vue/dist/vue.runtime.esm.js':
//     /*! **************************************************!*\
//   !*** ./node_modules/vue/dist/vue.runtime.esm.js ***!
//   \**************************************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__);
//       /* WEBPACK VAR INJECTION */(function (global, setImmediate) { /*!
//  * Vue.js v2.5.13
//  * (c) 2014-2017 Evan You
//  * Released under the MIT License.
//  */
//         /*  */

//         var emptyObject = Object.freeze({})

//         // these helpers produces better vm code in JS engines due to their
//         // explicitness and function inlining
//         function isUndef (v) {
//           return v === undefined || v === null
//         }

//         function isDef (v) {
//           return v !== undefined && v !== null
//         }

//         function isTrue (v) {
//           return v === true
//         }

//         function isFalse (v) {
//           return v === false
//         }

//         /**
//  * Check if value is primitive
//  */
//         function isPrimitive (value) {
//           return (
//             typeof value === 'string' ||
//     typeof value === 'number' ||
//     // $flow-disable-line
//     typeof value === 'symbol' ||
//     typeof value === 'boolean'
//           )
//         }

//         /**
//  * Quick object check - this is primarily used to tell
//  * Objects from primitive values when we know the value
//  * is a JSON-compliant type.
//  */
//         function isObject (obj) {
//           return obj !== null && typeof obj === 'object'
//         }

//         /**
//  * Get the raw type string of a value e.g. [object Object]
//  */
//         var _toString = Object.prototype.toString

//         function toRawType (value) {
//           return _toString.call(value).slice(8, -1)
//         }

//         /**
//  * Strict object type check. Only returns true
//  * for plain JavaScript objects.
//  */
//         function isPlainObject (obj) {
//           return _toString.call(obj) === '[object Object]'
//         }

//         function isRegExp (v) {
//           return _toString.call(v) === '[object RegExp]'
//         }

//         /**
//  * Check if val is a valid array index.
//  */
//         function isValidArrayIndex (val) {
//           var n = parseFloat(String(val))
//           return n >= 0 && Math.floor(n) === n && isFinite(val)
//         }

//         /**
//  * Convert a value to a string that is actually rendered.
//  */
//         function toString (val) {
//           return val == null
//             ? ''
//             : typeof val === 'object'
//               ? JSON.stringify(val, null, 2)
//               : String(val)
//         }

//         /**
//  * Convert a input value to a number for persistence.
//  * If the conversion fails, return original string.
//  */
//         function toNumber (val) {
//           var n = parseFloat(val)
//           return isNaN(n) ? val : n
//         }

//         /**
//  * Make a map and return a function for checking if a key
//  * is in that map.
//  */
//         function makeMap (
//           str,
//           expectsLowerCase
//         ) {
//           var map = Object.create(null)
//           var list = str.split(',')
//           for (var i = 0; i < list.length; i++) {
//             map[list[i]] = true
//           }
//           return expectsLowerCase
//             ? function (val) { return map[val.toLowerCase()] }
//             : function (val) { return map[val] }
//         }

//         /**
//  * Check if a tag is a built-in tag.
//  */
//         var isBuiltInTag = makeMap('slot,component', true)

//         /**
//  * Check if a attribute is a reserved attribute.
//  */
//         var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is')

//         /**
//  * Remove an item from an array
//  */
//         function remove (arr, item) {
//           if (arr.length) {
//             var index = arr.indexOf(item)
//             if (index > -1) {
//               return arr.splice(index, 1)
//             }
//           }
//         }

//         /**
//  * Check whether the object has the property.
//  */
//         var hasOwnProperty = Object.prototype.hasOwnProperty
//         function hasOwn (obj, key) {
//           return hasOwnProperty.call(obj, key)
//         }

//         /**
//  * Create a cached version of a pure function.
//  */
//         function cached (fn) {
//           var cache = Object.create(null)
//           return function cachedFn (str) {
//             var hit = cache[str]
//             return hit || (cache[str] = fn(str))
//           }
//         }

//         /**
//  * Camelize a hyphen-delimited string.
//  */
//         var camelizeRE = /-(\w)/g
//         var camelize = cached(function (str) {
//           return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : '' })
//         })

//         /**
//  * Capitalize a string.
//  */
//         var capitalize = cached(function (str) {
//           return str.charAt(0).toUpperCase() + str.slice(1)
//         })

//         /**
//  * Hyphenate a camelCase string.
//  */
//         var hyphenateRE = /\B([A-Z])/g
//         var hyphenate = cached(function (str) {
//           return str.replace(hyphenateRE, '-$1').toLowerCase()
//         })

//         /**
//  * Simple bind, faster than native
//  */
//         function bind (fn, ctx) {
//           function boundFn (a) {
//             var l = arguments.length
//             return l
//               ? l > 1
//                 ? fn.apply(ctx, arguments)
//                 : fn.call(ctx, a)
//               : fn.call(ctx)
//           }
//           // record original fn length
//           boundFn._length = fn.length
//           return boundFn
//         }

//         /**
//  * Convert an Array-like object to a real Array.
//  */
//         function toArray (list, start) {
//           start = start || 0
//           var i = list.length - start
//           var ret = new Array(i)
//           while (i--) {
//             ret[i] = list[i + start]
//           }
//           return ret
//         }

//         /**
//  * Mix properties into target object.
//  */
//         function extend (to, _from) {
//           for (var key in _from) {
//             to[key] = _from[key]
//           }
//           return to
//         }

//         /**
//  * Merge an Array of Objects into a single Object.
//  */
//         function toObject (arr) {
//           var res = {}
//           for (var i = 0; i < arr.length; i++) {
//             if (arr[i]) {
//               extend(res, arr[i])
//             }
//           }
//           return res
//         }

//         /**
//  * Perform no operation.
//  * Stubbing args to make Flow happy without leaving useless transpiled code
//  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)
//  */
//         function noop (a, b, c) {}

//         /**
//  * Always return false.
//  */
//         var no = function (a, b, c) { return false }

//         /**
//  * Return same value
//  */
//         var identity = function (_) { return _ }

//         /**
//  * Generate a static keys string from compiler modules.
//  */

//         /**
//  * Check if two values are loosely equal - that is,
//  * if they are plain objects, do they have the same shape?
//  */
//         function looseEqual (a, b) {
//           if (a === b) { return true }
//           var isObjectA = isObject(a)
//           var isObjectB = isObject(b)
//           if (isObjectA && isObjectB) {
//             try {
//               var isArrayA = Array.isArray(a)
//               var isArrayB = Array.isArray(b)
//               if (isArrayA && isArrayB) {
//                 return a.length === b.length && a.every(function (e, i) {
//                   return looseEqual(e, b[i])
//                 })
//               } else if (!isArrayA && !isArrayB) {
//                 var keysA = Object.keys(a)
//                 var keysB = Object.keys(b)
//                 return keysA.length === keysB.length && keysA.every(function (key) {
//                   return looseEqual(a[key], b[key])
//                 })
//               } else {
//                 /* istanbul ignore next */
//                 return false
//               }
//             } catch (e) {
//               /* istanbul ignore next */
//               return false
//             }
//           } else if (!isObjectA && !isObjectB) {
//             return String(a) === String(b)
//           } else {
//             return false
//           }
//         }

//         function looseIndexOf (arr, val) {
//           for (var i = 0; i < arr.length; i++) {
//             if (looseEqual(arr[i], val)) { return i }
//           }
//           return -1
//         }

//         /**
//  * Ensure a function is called only once.
//  */
//         function once (fn) {
//           var called = false
//           return function () {
//             if (!called) {
//               called = true
//               fn.apply(this, arguments)
//             }
//           }
//         }

//         var SSR_ATTR = 'data-server-rendered'

//         var ASSET_TYPES = [
//           'component',
//           'directive',
//           'filter'
//         ]

//         var LIFECYCLE_HOOKS = [
//           'beforeCreate',
//           'created',
//           'beforeMount',
//           'mounted',
//           'beforeUpdate',
//           'updated',
//           'beforeDestroy',
//           'destroyed',
//           'activated',
//           'deactivated',
//           'errorCaptured'
//         ]

//         /*  */

//         var config = ({
//           /**
//    * Option merge strategies (used in core/util/options)
//    */
//           // $flow-disable-line
//           optionMergeStrategies: Object.create(null),

//           /**
//    * Whether to suppress warnings.
//    */
//           silent: false,

//           /**
//    * Show production mode tip message on boot?
//    */
//           productionTip: 'development' !== 'production',

//           /**
//    * Whether to enable devtools
//    */
//           devtools: 'development' !== 'production',

//           /**
//    * Whether to record perf
//    */
//           performance: false,

//           /**
//    * Error handler for watcher errors
//    */
//           errorHandler: null,

//           /**
//    * Warn handler for watcher warns
//    */
//           warnHandler: null,

//           /**
//    * Ignore certain custom elements
//    */
//           ignoredElements: [],

//           /**
//    * Custom user key aliases for v-on
//    */
//           // $flow-disable-line
//           keyCodes: Object.create(null),

//           /**
//    * Check if a tag is reserved so that it cannot be registered as a
//    * component. This is platform-dependent and may be overwritten.
//    */
//           isReservedTag: no,

//           /**
//    * Check if an attribute is reserved so that it cannot be used as a component
//    * prop. This is platform-dependent and may be overwritten.
//    */
//           isReservedAttr: no,

//           /**
//    * Check if a tag is an unknown element.
//    * Platform-dependent.
//    */
//           isUnknownElement: no,

//           /**
//    * Get the namespace of an element
//    */
//           getTagNamespace: noop,

//           /**
//    * Parse the real tag name for the specific platform.
//    */
//           parsePlatformTagName: identity,

//           /**
//    * Check if an attribute must be bound using property, e.g. value
//    * Platform-dependent.
//    */
//           mustUseProp: no,

//           /**
//    * Exposed for legacy reasons
//    */
//           _lifecycleHooks: LIFECYCLE_HOOKS
//         })

//         /*  */

//         /**
//  * Check if a string starts with $ or _
//  */
//         function isReserved (str) {
//           var c = (str + '').charCodeAt(0)
//           return c === 0x24 || c === 0x5F
//         }

//         /**
//  * Define a property.
//  */
//         function def (obj, key, val, enumerable) {
//           Object.defineProperty(obj, key, {
//             value: val,
//             enumerable: !!enumerable,
//             writable: true,
//             configurable: true
//           })
//         }

//         /**
//  * Parse simple path.
//  */
//         var bailRE = /[^\w.$]/
//         function parsePath (path) {
//           if (bailRE.test(path)) {
//             return
//           }
//           var segments = path.split('.')
//           return function (obj) {
//             for (var i = 0; i < segments.length; i++) {
//               if (!obj) { return }
//               obj = obj[segments[i]]
//             }
//             return obj
//           }
//         }

//         /*  */

//         // can we use __proto__?
//         var hasProto = '__proto__' in {}

//         // Browser environment sniffing
//         var inBrowser = typeof window !== 'undefined'
//         var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform
//         var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase()
//         var UA = inBrowser && window.navigator.userAgent.toLowerCase()
//         var isIE = UA && /msie|trident/.test(UA)
//         var isIE9 = UA && UA.indexOf('msie 9.0') > 0
//         var isEdge = UA && UA.indexOf('edge/') > 0
//         var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android')
//         var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios')
//         var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge

//         // Firefox has a "watch" function on Object.prototype...
//         var nativeWatch = ({}).watch

//         var supportsPassive = false
//         if (inBrowser) {
//           try {
//             var opts = {}
//             Object.defineProperty(opts, 'passive', ({
//               get: function get () {
//                 /* istanbul ignore next */
//                 supportsPassive = true
//               }
//             })) // https://github.com/facebook/flow/issues/285
//             window.addEventListener('test-passive', null, opts)
//           } catch (e) {}
//         }

//         // this needs to be lazy-evaled because vue may be required before
//         // vue-server-renderer can set VUE_ENV
//         var _isServer
//         var isServerRendering = function () {
//           if (_isServer === undefined) {
//             /* istanbul ignore if */
//             if (!inBrowser && typeof global !== 'undefined') {
//               // detect presence of vue-server-renderer and avoid
//               // Webpack shimming the process
//               _isServer = global['process'].env.VUE_ENV === 'server'
//             } else {
//               _isServer = false
//             }
//           }
//           return _isServer
//         }

//         // detect devtools
//         var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__

//         /* istanbul ignore next */
//         function isNative (Ctor) {
//           return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
//         }

//         var hasSymbol =
//   typeof Symbol !== 'undefined' && isNative(Symbol) &&
//   typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys)

//         var _Set
//         /* istanbul ignore if */ // $flow-disable-line
//         if (typeof Set !== 'undefined' && isNative(Set)) {
//           // use native Set when available.
//           _Set = Set
//         } else {
//           // a non-standard Set polyfill that only works with primitive keys.
//           _Set = (function () {
//             function Set () {
//               this.set = Object.create(null)
//             }
//             Set.prototype.has = function has (key) {
//               return this.set[key] === true
//             }
//             Set.prototype.add = function add (key) {
//               this.set[key] = true
//             }
//             Set.prototype.clear = function clear () {
//               this.set = Object.create(null)
//             }

//             return Set
//           }())
//         }

//         /*  */

//         var warn = noop
//         var tip = noop
//         var generateComponentTrace = (noop) // work around flow check
//         var formatComponentName = (noop)

//         if (true) {
//           var hasConsole = typeof console !== 'undefined'
//           var classifyRE = /(?:^|[-_])(\w)/g
//           var classify = function (str) {
//             return str
//               .replace(classifyRE, function (c) { return c.toUpperCase() })
//               .replace(/[-_]/g, '')
//           }

//           warn = function (msg, vm) {
//             var trace = vm ? generateComponentTrace(vm) : ''

//             if (config.warnHandler) {
//               config.warnHandler.call(null, msg, vm, trace)
//             } else if (hasConsole && (!config.silent)) {
//               console.error(('[Vue warn]: ' + msg + trace))
//             }
//           }

//           tip = function (msg, vm) {
//             if (hasConsole && (!config.silent)) {
//               console.warn('[Vue tip]: ' + msg + (
//                 vm ? generateComponentTrace(vm) : ''
//               ))
//             }
//           }

//           formatComponentName = function (vm, includeFile) {
//             if (vm.$root === vm) {
//               return '<Root>'
//             }
//             var options = typeof vm === 'function' && vm.cid != null
//               ? vm.options
//               : vm._isVue
//                 ? vm.$options || vm.constructor.options
//                 : vm || {}
//             var name = options.name || options._componentTag
//             var file = options.__file
//             if (!name && file) {
//               var match = file.match(/([^/\\]+)\.vue$/)
//               name = match && match[1]
//             }

//             return (
//               (name ? ('<' + (classify(name)) + '>') : '<Anonymous>') +
//       (file && includeFile !== false ? (' at ' + file) : '')
//             )
//           }

//           var repeat = function (str, n) {
//             var res = ''
//             while (n) {
//               if (n % 2 === 1) { res += str }
//               if (n > 1) { str += str }
//               n >>= 1
//             }
//             return res
//           }

//           generateComponentTrace = function (vm) {
//             if (vm._isVue && vm.$parent) {
//               var tree = []
//               var currentRecursiveSequence = 0
//               while (vm) {
//                 if (tree.length > 0) {
//                   var last = tree[tree.length - 1]
//                   if (last.constructor === vm.constructor) {
//                     currentRecursiveSequence++
//                     vm = vm.$parent
//                     continue
//                   } else if (currentRecursiveSequence > 0) {
//                     tree[tree.length - 1] = [last, currentRecursiveSequence]
//                     currentRecursiveSequence = 0
//                   }
//                 }
//                 tree.push(vm)
//                 vm = vm.$parent
//               }
//               return '\n\nfound in\n\n' + tree
//                 .map(function (vm, i) {
//                   return ('' + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
//                     ? ((formatComponentName(vm[0])) + '... (' + (vm[1]) + ' recursive calls)')
//                     : formatComponentName(vm)))
//                 })
//                 .join('\n')
//             } else {
//               return ('\n\n(found in ' + (formatComponentName(vm)) + ')')
//             }
//           }
//         }

//         /*  */

//         var uid$1 = 0

//         /**
//  * A dep is an observable that can have multiple
//  * directives subscribing to it.
//  */
//         var Dep = function Dep () {
//           this.id = uid$1++
//           this.subs = []
//         }

//         Dep.prototype.addSub = function addSub (sub) {
//           this.subs.push(sub)
//         }

//         Dep.prototype.removeSub = function removeSub (sub) {
//           remove(this.subs, sub)
//         }

//         Dep.prototype.depend = function depend () {
//           if (Dep.target) {
//             Dep.target.addDep(this)
//           }
//         }

//         Dep.prototype.notify = function notify () {
//           // stabilize the subscriber list first
//           var subs = this.subs.slice()
//           for (var i = 0, l = subs.length; i < l; i++) {
//             subs[i].update()
//           }
//         }

//         // the current target watcher being evaluated.
//         // this is globally unique because there could be only one
//         // watcher being evaluated at any time.
//         Dep.target = null
//         var targetStack = []

//         function pushTarget (_target) {
//           if (Dep.target) { targetStack.push(Dep.target) }
//           Dep.target = _target
//         }

//         function popTarget () {
//           Dep.target = targetStack.pop()
//         }

//         /*  */

//         var VNode = function VNode (
//           tag,
//           data,
//           children,
//           text,
//           elm,
//           context,
//           componentOptions,
//           asyncFactory
//         ) {
//           this.tag = tag
//           this.data = data
//           this.children = children
//           this.text = text
//           this.elm = elm
//           this.ns = undefined
//           this.context = context
//           this.fnContext = undefined
//           this.fnOptions = undefined
//           this.fnScopeId = undefined
//           this.key = data && data.key
//           this.componentOptions = componentOptions
//           this.componentInstance = undefined
//           this.parent = undefined
//           this.raw = false
//           this.isStatic = false
//           this.isRootInsert = true
//           this.isComment = false
//           this.isCloned = false
//           this.isOnce = false
//           this.asyncFactory = asyncFactory
//           this.asyncMeta = undefined
//           this.isAsyncPlaceholder = false
//         }

//         var prototypeAccessors = { child: { configurable: true }}

//         // DEPRECATED: alias for componentInstance for backwards compat.
//         /* istanbul ignore next */
//         prototypeAccessors.child.get = function () {
//           return this.componentInstance
//         }

//         Object.defineProperties(VNode.prototype, prototypeAccessors)

//         var createEmptyVNode = function (text) {
//           if (text === void 0) text = ''

//           var node = new VNode()
//           node.text = text
//           node.isComment = true
//           return node
//         }

//         function createTextVNode (val) {
//           return new VNode(undefined, undefined, undefined, String(val))
//         }

//         // optimized shallow clone
//         // used for static nodes and slot nodes because they may be reused across
//         // multiple renders, cloning them avoids errors when DOM manipulations rely
//         // on their elm reference.
//         function cloneVNode (vnode, deep) {
//           var componentOptions = vnode.componentOptions
//           var cloned = new VNode(
//             vnode.tag,
//             vnode.data,
//             vnode.children,
//             vnode.text,
//             vnode.elm,
//             vnode.context,
//             componentOptions,
//             vnode.asyncFactory
//           )
//           cloned.ns = vnode.ns
//           cloned.isStatic = vnode.isStatic
//           cloned.key = vnode.key
//           cloned.isComment = vnode.isComment
//           cloned.fnContext = vnode.fnContext
//           cloned.fnOptions = vnode.fnOptions
//           cloned.fnScopeId = vnode.fnScopeId
//           cloned.isCloned = true
//           if (deep) {
//             if (vnode.children) {
//               cloned.children = cloneVNodes(vnode.children, true)
//             }
//             if (componentOptions && componentOptions.children) {
//               componentOptions.children = cloneVNodes(componentOptions.children, true)
//             }
//           }
//           return cloned
//         }

//         function cloneVNodes (vnodes, deep) {
//           var len = vnodes.length
//           var res = new Array(len)
//           for (var i = 0; i < len; i++) {
//             res[i] = cloneVNode(vnodes[i], deep)
//           }
//           return res
//         }

//         /*
//  * not type checking this file because flow doesn't play well with
//  * dynamically accessing methods on Array prototype
//  */

//         var arrayProto = Array.prototype
//         var arrayMethods = Object.create(arrayProto); [
//           'push',
//           'pop',
//           'shift',
//           'unshift',
//           'splice',
//           'sort',
//           'reverse'
//         ].forEach(function (method) {
//           // cache original method
//           var original = arrayProto[method]
//           def(arrayMethods, method, function mutator () {
//             var args = []; var len = arguments.length
//             while (len--) args[ len ] = arguments[ len ]

//             var result = original.apply(this, args)
//             var ob = this.__ob__
//             var inserted
//             switch (method) {
//               case 'push':
//               case 'unshift':
//                 inserted = args
//                 break
//               case 'splice':
//                 inserted = args.slice(2)
//                 break
//             }
//             if (inserted) { ob.observeArray(inserted) }
//             // notify change
//             ob.dep.notify()
//             return result
//           })
//         })

//         /*  */

//         var arrayKeys = Object.getOwnPropertyNames(arrayMethods)

//         /**
//  * By default, when a reactive property is set, the new value is
//  * also converted to become reactive. However when passing down props,
//  * we don't want to force conversion because the value may be a nested value
//  * under a frozen data structure. Converting it would defeat the optimization.
//  */
//         var observerState = {
//           shouldConvert: true
//         }

//         /**
//  * Observer class that are attached to each observed
//  * object. Once attached, the observer converts target
//  * object's property keys into getter/setters that
//  * collect dependencies and dispatches updates.
//  */
//         var Observer = function Observer (value) {
//           this.value = value
//           this.dep = new Dep()
//           this.vmCount = 0
//           def(value, '__ob__', this)
//           if (Array.isArray(value)) {
//             var augment = hasProto
//               ? protoAugment
//               : copyAugment
//             augment(value, arrayMethods, arrayKeys)
//             this.observeArray(value)
//           } else {
//             this.walk(value)
//           }
//         }

//         /**
//  * Walk through each property and convert them into
//  * getter/setters. This method should only be called when
//  * value type is Object.
//  */
//         Observer.prototype.walk = function walk (obj) {
//           var keys = Object.keys(obj)
//           for (var i = 0; i < keys.length; i++) {
//             defineReactive(obj, keys[i], obj[keys[i]])
//           }
//         }

//         /**
//  * Observe a list of Array items.
//  */
//         Observer.prototype.observeArray = function observeArray (items) {
//           for (var i = 0, l = items.length; i < l; i++) {
//             observe(items[i])
//           }
//         }

//         // helpers

//         /**
//  * Augment an target Object or Array by intercepting
//  * the prototype chain using __proto__
//  */
//         function protoAugment (target, src, keys) {
//           /* eslint-disable no-proto */
//           target.__proto__ = src
//           /* eslint-enable no-proto */
//         }

//         /**
//  * Augment an target Object or Array by defining
//  * hidden properties.
//  */
//         /* istanbul ignore next */
//         function copyAugment (target, src, keys) {
//           for (var i = 0, l = keys.length; i < l; i++) {
//             var key = keys[i]
//             def(target, key, src[key])
//           }
//         }

//         /**
//  * Attempt to create an observer instance for a value,
//  * returns the new observer if successfully observed,
//  * or the existing observer if the value already has one.
//  */
//         function observe (value, asRootData) {
//           if (!isObject(value) || value instanceof VNode) {
//             return
//           }
//           var ob
//           if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
//             ob = value.__ob__
//           } else if (
//             observerState.shouldConvert &&
//     !isServerRendering() &&
//     (Array.isArray(value) || isPlainObject(value)) &&
//     Object.isExtensible(value) &&
//     !value._isVue
//           ) {
//             ob = new Observer(value)
//           }
//           if (asRootData && ob) {
//             ob.vmCount++
//           }
//           return ob
//         }

//         /**
//  * Define a reactive property on an Object.
//  */
//         function defineReactive (
//           obj,
//           key,
//           val,
//           customSetter,
//           shallow
//         ) {
//           var dep = new Dep()

//           var property = Object.getOwnPropertyDescriptor(obj, key)
//           if (property && property.configurable === false) {
//             return
//           }

//           // cater for pre-defined getter/setters
//           var getter = property && property.get
//           var setter = property && property.set

//           var childOb = !shallow && observe(val)
//           Object.defineProperty(obj, key, {
//             enumerable: true,
//             configurable: true,
//             get: function reactiveGetter () {
//               var value = getter ? getter.call(obj) : val
//               if (Dep.target) {
//                 dep.depend()
//                 if (childOb) {
//                   childOb.dep.depend()
//                   if (Array.isArray(value)) {
//                     dependArray(value)
//                   }
//                 }
//               }
//               return value
//             },
//             set: function reactiveSetter (newVal) {
//               var value = getter ? getter.call(obj) : val
//               /* eslint-disable no-self-compare */
//               if (newVal === value || (newVal !== newVal && value !== value)) {
//                 return
//               }
//               /* eslint-enable no-self-compare */
//               if (true && customSetter) {
//                 customSetter()
//               }
//               if (setter) {
//                 setter.call(obj, newVal)
//               } else {
//                 val = newVal
//               }
//               childOb = !shallow && observe(newVal)
//               dep.notify()
//             }
//           })
//         }

//         /**
//  * Set a property on an object. Adds the new property and
//  * triggers change notification if the property doesn't
//  * already exist.
//  */
//         function set (target, key, val) {
//           if (Array.isArray(target) && isValidArrayIndex(key)) {
//             target.length = Math.max(target.length, key)
//             target.splice(key, 1, val)
//             return val
//           }
//           if (key in target && !(key in Object.prototype)) {
//             target[key] = val
//             return val
//           }
//           var ob = (target).__ob__
//           if (target._isVue || (ob && ob.vmCount)) {
//             true && warn(
//               'Avoid adding reactive properties to a Vue instance or its root $data ' +
//       'at runtime - declare it upfront in the data option.'
//             )
//             return val
//           }
//           if (!ob) {
//             target[key] = val
//             return val
//           }
//           defineReactive(ob.value, key, val)
//           ob.dep.notify()
//           return val
//         }

//         /**
//  * Delete a property and trigger change if necessary.
//  */
//         function del (target, key) {
//           if (Array.isArray(target) && isValidArrayIndex(key)) {
//             target.splice(key, 1)
//             return
//           }
//           var ob = (target).__ob__
//           if (target._isVue || (ob && ob.vmCount)) {
//             true && warn(
//               'Avoid deleting properties on a Vue instance or its root $data ' +
//       '- just set it to null.'
//             )
//             return
//           }
//           if (!hasOwn(target, key)) {
//             return
//           }
//           delete target[key]
//           if (!ob) {
//             return
//           }
//           ob.dep.notify()
//         }

//         /**
//  * Collect dependencies on array elements when the array is touched, since
//  * we cannot intercept array element access like property getters.
//  */
//         function dependArray (value) {
//           for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
//             e = value[i]
//             e && e.__ob__ && e.__ob__.dep.depend()
//             if (Array.isArray(e)) {
//               dependArray(e)
//             }
//           }
//         }

//         /*  */

//         /**
//  * Option overwriting strategies are functions that handle
//  * how to merge a parent option value and a child option
//  * value into the final value.
//  */
//         var strats = config.optionMergeStrategies

//         /**
//  * Options with restrictions
//  */
//         if (true) {
//           strats.el = strats.propsData = function (parent, child, vm, key) {
//             if (!vm) {
//               warn(
//                 'option "' + key + '" can only be used during instance ' +
//         'creation with the `new` keyword.'
//               )
//             }
//             return defaultStrat(parent, child)
//           }
//         }

//         /**
//  * Helper that recursively merges two data objects together.
//  */
//         function mergeData (to, from) {
//           if (!from) { return to }
//           var key, toVal, fromVal
//           var keys = Object.keys(from)
//           for (var i = 0; i < keys.length; i++) {
//             key = keys[i]
//             toVal = to[key]
//             fromVal = from[key]
//             if (!hasOwn(to, key)) {
//               set(to, key, fromVal)
//             } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {
//               mergeData(toVal, fromVal)
//             }
//           }
//           return to
//         }

//         /**
//  * Data
//  */
//         function mergeDataOrFn (
//           parentVal,
//           childVal,
//           vm
//         ) {
//           if (!vm) {
//             // in a Vue.extend merge, both should be functions
//             if (!childVal) {
//               return parentVal
//             }
//             if (!parentVal) {
//               return childVal
//             }
//             // when parentVal & childVal are both present,
//             // we need to return a function that returns the
//             // merged result of both functions... no need to
//             // check if parentVal is a function here because
//             // it has to be a function to pass previous merges.
//             return function mergedDataFn () {
//               return mergeData(
//                 typeof childVal === 'function' ? childVal.call(this, this) : childVal,
//                 typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
//               )
//             }
//           } else {
//             return function mergedInstanceDataFn () {
//               // instance merge
//               var instanceData = typeof childVal === 'function'
//                 ? childVal.call(vm, vm)
//                 : childVal
//               var defaultData = typeof parentVal === 'function'
//                 ? parentVal.call(vm, vm)
//                 : parentVal
//               if (instanceData) {
//                 return mergeData(instanceData, defaultData)
//               } else {
//                 return defaultData
//               }
//             }
//           }
//         }

//         strats.data = function (
//           parentVal,
//           childVal,
//           vm
//         ) {
//           if (!vm) {
//             if (childVal && typeof childVal !== 'function') {
//               true && warn(
//                 'The "data" option should be a function ' +
//         'that returns a per-instance value in component ' +
//         'definitions.',
//                 vm
//               )

//               return parentVal
//             }
//             return mergeDataOrFn(parentVal, childVal)
//           }

//           return mergeDataOrFn(parentVal, childVal, vm)
//         }

//         /**
//  * Hooks and props are merged as arrays.
//  */
//         function mergeHook (
//           parentVal,
//           childVal
//         ) {
//           return childVal
//             ? parentVal
//               ? parentVal.concat(childVal)
//               : Array.isArray(childVal)
//                 ? childVal
//                 : [childVal]
//             : parentVal
//         }

//         LIFECYCLE_HOOKS.forEach(function (hook) {
//           strats[hook] = mergeHook
//         })

//         /**
//  * Assets
//  *
//  * When a vm is present (instance creation), we need to do
//  * a three-way merge between constructor options, instance
//  * options and parent options.
//  */
//         function mergeAssets (
//           parentVal,
//           childVal,
//           vm,
//           key
//         ) {
//           var res = Object.create(parentVal || null)
//           if (childVal) {
//             true && assertObjectType(key, childVal, vm)
//             return extend(res, childVal)
//           } else {
//             return res
//           }
//         }

//         ASSET_TYPES.forEach(function (type) {
//           strats[type + 's'] = mergeAssets
//         })

//         /**
//  * Watchers.
//  *
//  * Watchers hashes should not overwrite one
//  * another, so we merge them as arrays.
//  */
//         strats.watch = function (
//           parentVal,
//           childVal,
//           vm,
//           key
//         ) {
//           // work around Firefox's Object.prototype.watch...
//           if (parentVal === nativeWatch) { parentVal = undefined }
//           if (childVal === nativeWatch) { childVal = undefined }
//           /* istanbul ignore if */
//           if (!childVal) { return Object.create(parentVal || null) }
//           if (true) {
//             assertObjectType(key, childVal, vm)
//           }
//           if (!parentVal) { return childVal }
//           var ret = {}
//           extend(ret, parentVal)
//           for (var key$1 in childVal) {
//             var parent = ret[key$1]
//             var child = childVal[key$1]
//             if (parent && !Array.isArray(parent)) {
//               parent = [parent]
//             }
//             ret[key$1] = parent
//               ? parent.concat(child)
//               : Array.isArray(child) ? child : [child]
//           }
//           return ret
//         }

//         /**
//  * Other object hashes.
//  */
//         strats.props =
// strats.methods =
// strats.inject =
// strats.computed = function (
//   parentVal,
//   childVal,
//   vm,
//   key
// ) {
//   if (childVal && 'development' !== 'production') {
//     assertObjectType(key, childVal, vm)
//   }
//   if (!parentVal) { return childVal }
//   var ret = Object.create(null)
//   extend(ret, parentVal)
//   if (childVal) { extend(ret, childVal) }
//   return ret
// }
//         strats.provide = mergeDataOrFn

//         /**
//  * Default strategy.
//  */
//         var defaultStrat = function (parentVal, childVal) {
//           return childVal === undefined
//             ? parentVal
//             : childVal
//         }

//         /**
//  * Validate component names
//  */
//         function checkComponents (options) {
//           for (var key in options.components) {
//             validateComponentName(key)
//           }
//         }

//         function validateComponentName (name) {
//           if (!/^[a-zA-Z][\w-]*$/.test(name)) {
//             warn(
//               'Invalid component name: "' + name + '". Component names ' +
//       'can only contain alphanumeric characters and the hyphen, ' +
//       'and must start with a letter.'
//             )
//           }
//           if (isBuiltInTag(name) || config.isReservedTag(name)) {
//             warn(
//               'Do not use built-in or reserved HTML elements as component ' +
//       'id: ' + name
//             )
//           }
//         }

//         /**
//  * Ensure all props option syntax are normalized into the
//  * Object-based format.
//  */
//         function normalizeProps (options, vm) {
//           var props = options.props
//           if (!props) { return }
//           var res = {}
//           var i, val, name
//           if (Array.isArray(props)) {
//             i = props.length
//             while (i--) {
//               val = props[i]
//               if (typeof val === 'string') {
//                 name = camelize(val)
//                 res[name] = { type: null }
//               } else if (true) {
//                 warn('props must be strings when using array syntax.')
//               }
//             }
//           } else if (isPlainObject(props)) {
//             for (var key in props) {
//               val = props[key]
//               name = camelize(key)
//               res[name] = isPlainObject(val)
//                 ? val
//                 : { type: val }
//             }
//           } else if (true) {
//             warn(
//               'Invalid value for option "props": expected an Array or an Object, ' +
//       'but got ' + (toRawType(props)) + '.',
//               vm
//             )
//           }
//           options.props = res
//         }

//         /**
//  * Normalize all injections into Object-based format
//  */
//         function normalizeInject (options, vm) {
//           var inject = options.inject
//           if (!inject) { return }
//           var normalized = options.inject = {}
//           if (Array.isArray(inject)) {
//             for (var i = 0; i < inject.length; i++) {
//               normalized[inject[i]] = { from: inject[i] }
//             }
//           } else if (isPlainObject(inject)) {
//             for (var key in inject) {
//               var val = inject[key]
//               normalized[key] = isPlainObject(val)
//                 ? extend({ from: key }, val)
//                 : { from: val }
//             }
//           } else if (true) {
//             warn(
//               'Invalid value for option "inject": expected an Array or an Object, ' +
//       'but got ' + (toRawType(inject)) + '.',
//               vm
//             )
//           }
//         }

//         /**
//  * Normalize raw function directives into object format.
//  */
//         function normalizeDirectives (options) {
//           var dirs = options.directives
//           if (dirs) {
//             for (var key in dirs) {
//               var def = dirs[key]
//               if (typeof def === 'function') {
//                 dirs[key] = { bind: def, update: def }
//               }
//             }
//           }
//         }

//         function assertObjectType (name, value, vm) {
//           if (!isPlainObject(value)) {
//             warn(
//               'Invalid value for option "' + name + '": expected an Object, ' +
//       'but got ' + (toRawType(value)) + '.',
//               vm
//             )
//           }
//         }

//         /**
//  * Merge two option objects into a new one.
//  * Core utility used in both instantiation and inheritance.
//  */
//         function mergeOptions (
//           parent,
//           child,
//           vm
//         ) {
//           if (true) {
//             checkComponents(child)
//           }

//           if (typeof child === 'function') {
//             child = child.options
//           }

//           normalizeProps(child, vm)
//           normalizeInject(child, vm)
//           normalizeDirectives(child)
//           var extendsFrom = child.extends
//           if (extendsFrom) {
//             parent = mergeOptions(parent, extendsFrom, vm)
//           }
//           if (child.mixins) {
//             for (var i = 0, l = child.mixins.length; i < l; i++) {
//               parent = mergeOptions(parent, child.mixins[i], vm)
//             }
//           }
//           var options = {}
//           var key
//           for (key in parent) {
//             mergeField(key)
//           }
//           for (key in child) {
//             if (!hasOwn(parent, key)) {
//               mergeField(key)
//             }
//           }
//           function mergeField (key) {
//             var strat = strats[key] || defaultStrat
//             options[key] = strat(parent[key], child[key], vm, key)
//           }
//           return options
//         }

//         /**
//  * Resolve an asset.
//  * This function is used because child instances need access
//  * to assets defined in its ancestor chain.
//  */
//         function resolveAsset (
//           options,
//           type,
//           id,
//           warnMissing
//         ) {
//           /* istanbul ignore if */
//           if (typeof id !== 'string') {
//             return
//           }
//           var assets = options[type]
//           // check local registration variations first
//           if (hasOwn(assets, id)) { return assets[id] }
//           var camelizedId = camelize(id)
//           if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
//           var PascalCaseId = capitalize(camelizedId)
//           if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
//           // fallback to prototype chain
//           var res = assets[id] || assets[camelizedId] || assets[PascalCaseId]
//           if (true && warnMissing && !res) {
//             warn(
//               'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
//               options
//             )
//           }
//           return res
//         }

//         /*  */

//         function validateProp (
//           key,
//           propOptions,
//           propsData,
//           vm
//         ) {
//           var prop = propOptions[key]
//           var absent = !hasOwn(propsData, key)
//           var value = propsData[key]
//           // handle boolean props
//           if (isType(Boolean, prop.type)) {
//             if (absent && !hasOwn(prop, 'default')) {
//               value = false
//             } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {
//               value = true
//             }
//           }
//           // check default value
//           if (value === undefined) {
//             value = getPropDefaultValue(vm, prop, key)
//             // since the default value is a fresh copy,
//             // make sure to observe it.
//             var prevShouldConvert = observerState.shouldConvert
//             observerState.shouldConvert = true
//             observe(value)
//             observerState.shouldConvert = prevShouldConvert
//           }
//           if (
//             true
//           ) {
//             assertProp(prop, key, value, vm, absent)
//           }
//           return value
//         }

//         /**
//  * Get the default value of a prop.
//  */
//         function getPropDefaultValue (vm, prop, key) {
//           // no default, return undefined
//           if (!hasOwn(prop, 'default')) {
//             return undefined
//           }
//           var def = prop.default
//           // warn against non-factory defaults for Object & Array
//           if (true && isObject(def)) {
//             warn(
//               'Invalid default value for prop "' + key + '": ' +
//       'Props with type Object/Array must use a factory function ' +
//       'to return the default value.',
//               vm
//             )
//           }
//           // the raw prop value was also undefined from previous render,
//           // return previous default value to avoid unnecessary watcher trigger
//           if (vm && vm.$options.propsData &&
//     vm.$options.propsData[key] === undefined &&
//     vm._props[key] !== undefined
//           ) {
//             return vm._props[key]
//           }
//           // call factory function for non-Function types
//           // a value is Function if its prototype is function even across different execution context
//           return typeof def === 'function' && getType(prop.type) !== 'Function'
//             ? def.call(vm)
//             : def
//         }

//         /**
//  * Assert whether a prop is valid.
//  */
//         function assertProp (
//           prop,
//           name,
//           value,
//           vm,
//           absent
//         ) {
//           if (prop.required && absent) {
//             warn(
//               'Missing required prop: "' + name + '"',
//               vm
//             )
//             return
//           }
//           if (value == null && !prop.required) {
//             return
//           }
//           var type = prop.type
//           var valid = !type || type === true
//           var expectedTypes = []
//           if (type) {
//             if (!Array.isArray(type)) {
//               type = [type]
//             }
//             for (var i = 0; i < type.length && !valid; i++) {
//               var assertedType = assertType(value, type[i])
//               expectedTypes.push(assertedType.expectedType || '')
//               valid = assertedType.valid
//             }
//           }
//           if (!valid) {
//             warn(
//               'Invalid prop: type check failed for prop "' + name + '".' +
//       ' Expected ' + (expectedTypes.map(capitalize).join(', ')) +
//       ', got ' + (toRawType(value)) + '.',
//               vm
//             )
//             return
//           }
//           var validator = prop.validator
//           if (validator) {
//             if (!validator(value)) {
//               warn(
//                 'Invalid prop: custom validator check failed for prop "' + name + '".',
//                 vm
//               )
//             }
//           }
//         }

//         var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/

//         function assertType (value, type) {
//           var valid
//           var expectedType = getType(type)
//           if (simpleCheckRE.test(expectedType)) {
//             var t = typeof value
//             valid = t === expectedType.toLowerCase()
//             // for primitive wrapper objects
//             if (!valid && t === 'object') {
//               valid = value instanceof type
//             }
//           } else if (expectedType === 'Object') {
//             valid = isPlainObject(value)
//           } else if (expectedType === 'Array') {
//             valid = Array.isArray(value)
//           } else {
//             valid = value instanceof type
//           }
//           return {
//             valid: valid,
//             expectedType: expectedType
//           }
//         }

//         /**
//  * Use function string name to check built-in types,
//  * because a simple equality check will fail when running
//  * across different vms / iframes.
//  */
//         function getType (fn) {
//           var match = fn && fn.toString().match(/^\s*function (\w+)/)
//           return match ? match[1] : ''
//         }

//         function isType (type, fn) {
//           if (!Array.isArray(fn)) {
//             return getType(fn) === getType(type)
//           }
//           for (var i = 0, len = fn.length; i < len; i++) {
//             if (getType(fn[i]) === getType(type)) {
//               return true
//             }
//           }
//           /* istanbul ignore next */
//           return false
//         }

//         /*  */

//         function handleError (err, vm, info) {
//           if (vm) {
//             var cur = vm
//             while ((cur = cur.$parent)) {
//               var hooks = cur.$options.errorCaptured
//               if (hooks) {
//                 for (var i = 0; i < hooks.length; i++) {
//                   try {
//                     var capture = hooks[i].call(cur, err, vm, info) === false
//                     if (capture) { return }
//                   } catch (e) {
//                     globalHandleError(e, cur, 'errorCaptured hook')
//                   }
//                 }
//               }
//             }
//           }
//           globalHandleError(err, vm, info)
//         }

//         function globalHandleError (err, vm, info) {
//           if (config.errorHandler) {
//             try {
//               return config.errorHandler.call(null, err, vm, info)
//             } catch (e) {
//               logError(e, null, 'config.errorHandler')
//             }
//           }
//           logError(err, vm, info)
//         }

//         function logError (err, vm, info) {
//           if (true) {
//             warn(('Error in ' + info + ': "' + (err.toString()) + '"'), vm)
//           }
//           /* istanbul ignore else */
//           if ((inBrowser || inWeex) && typeof console !== 'undefined') {
//             console.error(err)
//           } else {
//             throw err
//           }
//         }

//         /*  */
//         /* globals MessageChannel */

//         var callbacks = []
//         var pending = false

//         function flushCallbacks () {
//           pending = false
//           var copies = callbacks.slice(0)
//           callbacks.length = 0
//           for (var i = 0; i < copies.length; i++) {
//             copies[i]()
//           }
//         }

//         // Here we have async deferring wrappers using both micro and macro tasks.
//         // In < 2.4 we used micro tasks everywhere, but there are some scenarios where
//         // micro tasks have too high a priority and fires in between supposedly
//         // sequential events (e.g. #4521, #6690) or even between bubbling of the same
//         // event (#6566). However, using macro tasks everywhere also has subtle problems
//         // when state is changed right before repaint (e.g. #6813, out-in transitions).
//         // Here we use micro task by default, but expose a way to force macro task when
//         // needed (e.g. in event handlers attached by v-on).
//         var microTimerFunc
//         var macroTimerFunc
//         var useMacroTask = false

//         // Determine (macro) Task defer implementation.
//         // Technically setImmediate should be the ideal choice, but it's only available
//         // in IE. The only polyfill that consistently queues the callback after all DOM
//         // events triggered in the same loop is by using MessageChannel.
//         /* istanbul ignore if */
//         if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
//           macroTimerFunc = function () {
//             setImmediate(flushCallbacks)
//           }
//         } else if (typeof MessageChannel !== 'undefined' && (
//           isNative(MessageChannel) ||
//   // PhantomJS
//   MessageChannel.toString() === '[object MessageChannelConstructor]'
//         )) {
//           var channel = new MessageChannel()
//           var port = channel.port2
//           channel.port1.onmessage = flushCallbacks
//           macroTimerFunc = function () {
//             port.postMessage(1)
//           }
//         } else {
//           /* istanbul ignore next */
//           macroTimerFunc = function () {
//             setTimeout(flushCallbacks, 0)
//           }
//         }

//         // Determine MicroTask defer implementation.
//         /* istanbul ignore next, $flow-disable-line */
//         if (typeof Promise !== 'undefined' && isNative(Promise)) {
//           var p = Promise.resolve()
//           microTimerFunc = function () {
//             p.then(flushCallbacks)
//             // in problematic UIWebViews, Promise.then doesn't completely break, but
//             // it can get stuck in a weird state where callbacks are pushed into the
//             // microtask queue but the queue isn't being flushed, until the browser
//             // needs to do some other work, e.g. handle a timer. Therefore we can
//             // "force" the microtask queue to be flushed by adding an empty timer.
//             if (isIOS) { setTimeout(noop) }
//           }
//         } else {
//           // fallback to macro
//           microTimerFunc = macroTimerFunc
//         }

//         /**
//  * Wrap a function so that if any code inside triggers state change,
//  * the changes are queued using a Task instead of a MicroTask.
//  */
//         function withMacroTask (fn) {
//           return fn._withTask || (fn._withTask = function () {
//             useMacroTask = true
//             var res = fn.apply(null, arguments)
//             useMacroTask = false
//             return res
//           })
//         }

//         function nextTick (cb, ctx) {
//           var _resolve
//           callbacks.push(function () {
//             if (cb) {
//               try {
//                 cb.call(ctx)
//               } catch (e) {
//                 handleError(e, ctx, 'nextTick')
//               }
//             } else if (_resolve) {
//               _resolve(ctx)
//             }
//           })
//           if (!pending) {
//             pending = true
//             if (useMacroTask) {
//               macroTimerFunc()
//             } else {
//               microTimerFunc()
//             }
//           }
//           // $flow-disable-line
//           if (!cb && typeof Promise !== 'undefined') {
//             return new Promise(function (resolve) {
//               _resolve = resolve
//             })
//           }
//         }

//         /*  */

//         /* not type checking this file because flow doesn't play well with Proxy */

//         var initProxy

//         if (true) {
//           var allowedGlobals = makeMap(
//             'Infinity,undefined,NaN,isFinite,isNaN,' +
//     'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
//     'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
//     'require' // for Webpack/Browserify
//           )

//           var warnNonPresent = function (target, key) {
//             warn(
//               'Property or method "' + key + '" is not defined on the instance but ' +
//       'referenced during render. Make sure that this property is reactive, ' +
//       'either in the data option, or for class-based components, by ' +
//       'initializing the property. ' +
//       'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
//               target
//             )
//           }

//           var hasProxy =
//     typeof Proxy !== 'undefined' &&
//     Proxy.toString().match(/native code/)

//           if (hasProxy) {
//             var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact')
//             config.keyCodes = new Proxy(config.keyCodes, {
//               set: function set (target, key, value) {
//                 if (isBuiltInModifier(key)) {
//                   warn(('Avoid overwriting built-in modifier in config.keyCodes: .' + key))
//                   return false
//                 } else {
//                   target[key] = value
//                   return true
//                 }
//               }
//             })
//           }

//           var hasHandler = {
//             has: function has (target, key) {
//               var has = key in target
//               var isAllowed = allowedGlobals(key) || key.charAt(0) === '_'
//               if (!has && !isAllowed) {
//                 warnNonPresent(target, key)
//               }
//               return has || !isAllowed
//             }
//           }

//           var getHandler = {
//             get: function get (target, key) {
//               if (typeof key === 'string' && !(key in target)) {
//                 warnNonPresent(target, key)
//               }
//               return target[key]
//             }
//           }

//           initProxy = function initProxy (vm) {
//             if (hasProxy) {
//               // determine which proxy handler to use
//               var options = vm.$options
//               var handlers = options.render && options.render._withStripped
//                 ? getHandler
//                 : hasHandler
//               vm._renderProxy = new Proxy(vm, handlers)
//             } else {
//               vm._renderProxy = vm
//             }
//           }
//         }

//         /*  */

//         var seenObjects = new _Set()

//         /**
//  * Recursively traverse an object to evoke all converted
//  * getters, so that every nested property inside the object
//  * is collected as a "deep" dependency.
//  */
//         function traverse (val) {
//           _traverse(val, seenObjects)
//           seenObjects.clear()
//         }

//         function _traverse (val, seen) {
//           var i, keys
//           var isA = Array.isArray(val)
//           if ((!isA && !isObject(val)) || Object.isFrozen(val)) {
//             return
//           }
//           if (val.__ob__) {
//             var depId = val.__ob__.dep.id
//             if (seen.has(depId)) {
//               return
//             }
//             seen.add(depId)
//           }
//           if (isA) {
//             i = val.length
//             while (i--) { _traverse(val[i], seen) }
//           } else {
//             keys = Object.keys(val)
//             i = keys.length
//             while (i--) { _traverse(val[keys[i]], seen) }
//           }
//         }

//         var mark
//         var measure

//         if (true) {
//           var perf = inBrowser && window.performance
//           /* istanbul ignore if */
//           if (
//             perf &&
//     perf.mark &&
//     perf.measure &&
//     perf.clearMarks &&
//     perf.clearMeasures
//           ) {
//             mark = function (tag) { return perf.mark(tag) }
//             measure = function (name, startTag, endTag) {
//               perf.measure(name, startTag, endTag)
//               perf.clearMarks(startTag)
//               perf.clearMarks(endTag)
//               perf.clearMeasures(name)
//             }
//           }
//         }

//         /*  */

//         var normalizeEvent = cached(function (name) {
//           var passive = name.charAt(0) === '&'
//           name = passive ? name.slice(1) : name
//           var once$$1 = name.charAt(0) === '~' // Prefixed last, checked first
//           name = once$$1 ? name.slice(1) : name
//           var capture = name.charAt(0) === '!'
//           name = capture ? name.slice(1) : name
//           return {
//             name: name,
//             once: once$$1,
//             capture: capture,
//             passive: passive
//           }
//         })

//         function createFnInvoker (fns) {
//           function invoker () {
//             var arguments$1 = arguments

//             var fns = invoker.fns
//             if (Array.isArray(fns)) {
//               var cloned = fns.slice()
//               for (var i = 0; i < cloned.length; i++) {
//                 cloned[i].apply(null, arguments$1)
//               }
//             } else {
//               // return handler return value for single handlers
//               return fns.apply(null, arguments)
//             }
//           }
//           invoker.fns = fns
//           return invoker
//         }

//         function updateListeners (
//           on,
//           oldOn,
//           add,
//           remove$$1,
//           vm
//         ) {
//           var name, def, cur, old, event
//           for (name in on) {
//             def = cur = on[name]
//             old = oldOn[name]
//             event = normalizeEvent(name)
//             /* istanbul ignore if */
//             if (isUndef(cur)) {
//               true && warn(
//                 'Invalid handler for event "' + (event.name) + '": got ' + String(cur),
//                 vm
//               )
//             } else if (isUndef(old)) {
//               if (isUndef(cur.fns)) {
//                 cur = on[name] = createFnInvoker(cur)
//               }
//               add(event.name, cur, event.once, event.capture, event.passive, event.params)
//             } else if (cur !== old) {
//               old.fns = cur
//               on[name] = old
//             }
//           }
//           for (name in oldOn) {
//             if (isUndef(on[name])) {
//               event = normalizeEvent(name)
//               remove$$1(event.name, oldOn[name], event.capture)
//             }
//           }
//         }

//         /*  */

//         function mergeVNodeHook (def, hookKey, hook) {
//           if (def instanceof VNode) {
//             def = def.data.hook || (def.data.hook = {})
//           }
//           var invoker
//           var oldHook = def[hookKey]

//           function wrappedHook () {
//             hook.apply(this, arguments)
//             // important: remove merged hook to ensure it's called only once
//             // and prevent memory leak
//             remove(invoker.fns, wrappedHook)
//           }

//           if (isUndef(oldHook)) {
//             // no existing hook
//             invoker = createFnInvoker([wrappedHook])
//           } else {
//             /* istanbul ignore if */
//             if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
//               // already a merged invoker
//               invoker = oldHook
//               invoker.fns.push(wrappedHook)
//             } else {
//               // existing plain hook
//               invoker = createFnInvoker([oldHook, wrappedHook])
//             }
//           }

//           invoker.merged = true
//           def[hookKey] = invoker
//         }

//         /*  */

//         function extractPropsFromVNodeData (
//           data,
//           Ctor,
//           tag
//         ) {
//           // we are only extracting raw values here.
//           // validation and default values are handled in the child
//           // component itself.
//           var propOptions = Ctor.options.props
//           if (isUndef(propOptions)) {
//             return
//           }
//           var res = {}
//           var attrs = data.attrs
//           var props = data.props
//           if (isDef(attrs) || isDef(props)) {
//             for (var key in propOptions) {
//               var altKey = hyphenate(key)
//               if (true) {
//                 var keyInLowerCase = key.toLowerCase()
//                 if (
//                   key !== keyInLowerCase &&
//           attrs && hasOwn(attrs, keyInLowerCase)
//                 ) {
//                   tip(
//                     'Prop "' + keyInLowerCase + '" is passed to component ' +
//             (formatComponentName(tag || Ctor)) + ', but the declared prop name is' +
//             ' "' + key + '". ' +
//             'Note that HTML attributes are case-insensitive and camelCased ' +
//             'props need to use their kebab-case equivalents when using in-DOM ' +
//             'templates. You should probably use "' + altKey + '" instead of "' + key + '".'
//                   )
//                 }
//               }
//               checkProp(res, props, key, altKey, true) ||
//       checkProp(res, attrs, key, altKey, false)
//             }
//           }
//           return res
//         }

//         function checkProp (
//           res,
//           hash,
//           key,
//           altKey,
//           preserve
//         ) {
//           if (isDef(hash)) {
//             if (hasOwn(hash, key)) {
//               res[key] = hash[key]
//               if (!preserve) {
//                 delete hash[key]
//               }
//               return true
//             } else if (hasOwn(hash, altKey)) {
//               res[key] = hash[altKey]
//               if (!preserve) {
//                 delete hash[altKey]
//               }
//               return true
//             }
//           }
//           return false
//         }

//         /*  */

//         // The template compiler attempts to minimize the need for normalization by
//         // statically analyzing the template at compile time.
//         //
//         // For plain HTML markup, normalization can be completely skipped because the
//         // generated render function is guaranteed to return Array<VNode>. There are
//         // two cases where extra normalization is needed:

//         // 1. When the children contains components - because a functional component
//         // may return an Array instead of a single root. In this case, just a simple
//         // normalization is needed - if any child is an Array, we flatten the whole
//         // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
//         // because functional components already normalize their own children.
//         function simpleNormalizeChildren (children) {
//           for (var i = 0; i < children.length; i++) {
//             if (Array.isArray(children[i])) {
//               return Array.prototype.concat.apply([], children)
//             }
//           }
//           return children
//         }

//         // 2. When the children contains constructs that always generated nested Arrays,
//         // e.g. <template>, <slot>, v-for, or when the children is provided by user
//         // with hand-written render functions / JSX. In such cases a full normalization
//         // is needed to cater to all possible types of children values.
//         function normalizeChildren (children) {
//           return isPrimitive(children)
//             ? [createTextVNode(children)]
//             : Array.isArray(children)
//               ? normalizeArrayChildren(children)
//               : undefined
//         }

//         function isTextNode (node) {
//           return isDef(node) && isDef(node.text) && isFalse(node.isComment)
//         }

//         function normalizeArrayChildren (children, nestedIndex) {
//           var res = []
//           var i, c, lastIndex, last
//           for (i = 0; i < children.length; i++) {
//             c = children[i]
//             if (isUndef(c) || typeof c === 'boolean') { continue }
//             lastIndex = res.length - 1
//             last = res[lastIndex]
//             //  nested
//             if (Array.isArray(c)) {
//               if (c.length > 0) {
//                 c = normalizeArrayChildren(c, ((nestedIndex || '') + '_' + i))
//                 // merge adjacent text nodes
//                 if (isTextNode(c[0]) && isTextNode(last)) {
//                   res[lastIndex] = createTextVNode(last.text + (c[0]).text)
//                   c.shift()
//                 }
//                 res.push.apply(res, c)
//               }
//             } else if (isPrimitive(c)) {
//               if (isTextNode(last)) {
//                 // merge adjacent text nodes
//                 // this is necessary for SSR hydration because text nodes are
//                 // essentially merged when rendered to HTML strings
//                 res[lastIndex] = createTextVNode(last.text + c)
//               } else if (c !== '') {
//                 // convert primitive to vnode
//                 res.push(createTextVNode(c))
//               }
//             } else {
//               if (isTextNode(c) && isTextNode(last)) {
//                 // merge adjacent text nodes
//                 res[lastIndex] = createTextVNode(last.text + c.text)
//               } else {
//                 // default key for nested array children (likely generated by v-for)
//                 if (isTrue(children._isVList) &&
//           isDef(c.tag) &&
//           isUndef(c.key) &&
//           isDef(nestedIndex)) {
//                   c.key = '__vlist' + nestedIndex + '_' + i + '__'
//                 }
//                 res.push(c)
//               }
//             }
//           }
//           return res
//         }

//         /*  */

//         function ensureCtor (comp, base) {
//           if (
//             comp.__esModule ||
//     (hasSymbol && comp[Symbol.toStringTag] === 'Module')
//           ) {
//             comp = comp.default
//           }
//           return isObject(comp)
//             ? base.extend(comp)
//             : comp
//         }

//         function createAsyncPlaceholder (
//           factory,
//           data,
//           context,
//           children,
//           tag
//         ) {
//           var node = createEmptyVNode()
//           node.asyncFactory = factory
//           node.asyncMeta = { data: data, context: context, children: children, tag: tag }
//           return node
//         }

//         function resolveAsyncComponent (
//           factory,
//           baseCtor,
//           context
//         ) {
//           if (isTrue(factory.error) && isDef(factory.errorComp)) {
//             return factory.errorComp
//           }

//           if (isDef(factory.resolved)) {
//             return factory.resolved
//           }

//           if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
//             return factory.loadingComp
//           }

//           if (isDef(factory.contexts)) {
//             // already pending
//             factory.contexts.push(context)
//           } else {
//             var contexts = factory.contexts = [context]
//             var sync = true

//             var forceRender = function () {
//               for (var i = 0, l = contexts.length; i < l; i++) {
//                 contexts[i].$forceUpdate()
//               }
//             }

//             var resolve = once(function (res) {
//               // cache resolved
//               factory.resolved = ensureCtor(res, baseCtor)
//               // invoke callbacks only if this is not a synchronous resolve
//               // (async resolves are shimmed as synchronous during SSR)
//               if (!sync) {
//                 forceRender()
//               }
//             })

//             var reject = once(function (reason) {
//               true && warn(
//                 'Failed to resolve async component: ' + (String(factory)) +
//         (reason ? ('\nReason: ' + reason) : '')
//               )
//               if (isDef(factory.errorComp)) {
//                 factory.error = true
//                 forceRender()
//               }
//             })

//             var res = factory(resolve, reject)

//             if (isObject(res)) {
//               if (typeof res.then === 'function') {
//                 // () => Promise
//                 if (isUndef(factory.resolved)) {
//                   res.then(resolve, reject)
//                 }
//               } else if (isDef(res.component) && typeof res.component.then === 'function') {
//                 res.component.then(resolve, reject)

//                 if (isDef(res.error)) {
//                   factory.errorComp = ensureCtor(res.error, baseCtor)
//                 }

//                 if (isDef(res.loading)) {
//                   factory.loadingComp = ensureCtor(res.loading, baseCtor)
//                   if (res.delay === 0) {
//                     factory.loading = true
//                   } else {
//                     setTimeout(function () {
//                       if (isUndef(factory.resolved) && isUndef(factory.error)) {
//                         factory.loading = true
//                         forceRender()
//                       }
//                     }, res.delay || 200)
//                   }
//                 }

//                 if (isDef(res.timeout)) {
//                   setTimeout(function () {
//                     if (isUndef(factory.resolved)) {
//                       reject(
//                         true
//                           ? ('timeout (' + (res.timeout) + 'ms)')
//                           : undefined
//                       )
//                     }
//                   }, res.timeout)
//                 }
//               }
//             }

//             sync = false
//             // return in case resolved synchronously
//             return factory.loading
//               ? factory.loadingComp
//               : factory.resolved
//           }
//         }

//         /*  */

//         function isAsyncPlaceholder (node) {
//           return node.isComment && node.asyncFactory
//         }

//         /*  */

//         function getFirstComponentChild (children) {
//           if (Array.isArray(children)) {
//             for (var i = 0; i < children.length; i++) {
//               var c = children[i]
//               if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
//                 return c
//               }
//             }
//           }
//         }

//         /*  */

//         /*  */

//         function initEvents (vm) {
//           vm._events = Object.create(null)
//           vm._hasHookEvent = false
//           // init parent attached events
//           var listeners = vm.$options._parentListeners
//           if (listeners) {
//             updateComponentListeners(vm, listeners)
//           }
//         }

//         var target

//         function add (event, fn, once) {
//           if (once) {
//             target.$once(event, fn)
//           } else {
//             target.$on(event, fn)
//           }
//         }

//         function remove$1 (event, fn) {
//           target.$off(event, fn)
//         }

//         function updateComponentListeners (
//           vm,
//           listeners,
//           oldListeners
//         ) {
//           target = vm
//           updateListeners(listeners, oldListeners || {}, add, remove$1, vm)
//           target = undefined
//         }

//         function eventsMixin (Vue) {
//           var hookRE = /^hook:/
//           Vue.prototype.$on = function (event, fn) {
//             var this$1 = this

//             var vm = this
//             if (Array.isArray(event)) {
//               for (var i = 0, l = event.length; i < l; i++) {
//                 this$1.$on(event[i], fn)
//               }
//             } else {
//               (vm._events[event] || (vm._events[event] = [])).push(fn)
//               // optimize hook:event cost by using a boolean flag marked at registration
//               // instead of a hash lookup
//               if (hookRE.test(event)) {
//                 vm._hasHookEvent = true
//               }
//             }
//             return vm
//           }

//           Vue.prototype.$once = function (event, fn) {
//             var vm = this
//             function on () {
//               vm.$off(event, on)
//               fn.apply(vm, arguments)
//             }
//             on.fn = fn
//             vm.$on(event, on)
//             return vm
//           }

//           Vue.prototype.$off = function (event, fn) {
//             var this$1 = this

//             var vm = this
//             // all
//             if (!arguments.length) {
//               vm._events = Object.create(null)
//               return vm
//             }
//             // array of events
//             if (Array.isArray(event)) {
//               for (var i = 0, l = event.length; i < l; i++) {
//                 this$1.$off(event[i], fn)
//               }
//               return vm
//             }
//             // specific event
//             var cbs = vm._events[event]
//             if (!cbs) {
//               return vm
//             }
//             if (!fn) {
//               vm._events[event] = null
//               return vm
//             }
//             if (fn) {
//               // specific handler
//               var cb
//               var i$1 = cbs.length
//               while (i$1--) {
//                 cb = cbs[i$1]
//                 if (cb === fn || cb.fn === fn) {
//                   cbs.splice(i$1, 1)
//                   break
//                 }
//               }
//             }
//             return vm
//           }

//           Vue.prototype.$emit = function (event) {
//             var vm = this
//             if (true) {
//               var lowerCaseEvent = event.toLowerCase()
//               if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
//                 tip(
//                   'Event "' + lowerCaseEvent + '" is emitted in component ' +
//           (formatComponentName(vm)) + ' but the handler is registered for "' + event + '". ' +
//           'Note that HTML attributes are case-insensitive and you cannot use ' +
//           'v-on to listen to camelCase events when using in-DOM templates. ' +
//           'You should probably use "' + (hyphenate(event)) + '" instead of "' + event + '".'
//                 )
//               }
//             }
//             var cbs = vm._events[event]
//             if (cbs) {
//               cbs = cbs.length > 1 ? toArray(cbs) : cbs
//               var args = toArray(arguments, 1)
//               for (var i = 0, l = cbs.length; i < l; i++) {
//                 try {
//                   cbs[i].apply(vm, args)
//                 } catch (e) {
//                   handleError(e, vm, ('event handler for "' + event + '"'))
//                 }
//               }
//             }
//             return vm
//           }
//         }

//         /*  */

//         /**
//  * Runtime helper for resolving raw children VNodes into a slot object.
//  */
//         function resolveSlots (
//           children,
//           context
//         ) {
//           var slots = {}
//           if (!children) {
//             return slots
//           }
//           for (var i = 0, l = children.length; i < l; i++) {
//             var child = children[i]
//             var data = child.data
//             // remove slot attribute if the node is resolved as a Vue slot node
//             if (data && data.attrs && data.attrs.slot) {
//               delete data.attrs.slot
//             }
//             // named slots should only be respected if the vnode was rendered in the
//             // same context.
//             if ((child.context === context || child.fnContext === context) &&
//       data && data.slot != null
//             ) {
//               var name = data.slot
//               var slot = (slots[name] || (slots[name] = []))
//               if (child.tag === 'template') {
//                 slot.push.apply(slot, child.children || [])
//               } else {
//                 slot.push(child)
//               }
//             } else {
//               (slots.default || (slots.default = [])).push(child)
//             }
//           }
//           // ignore slots that contains only whitespace
//           for (var name$1 in slots) {
//             if (slots[name$1].every(isWhitespace)) {
//               delete slots[name$1]
//             }
//           }
//           return slots
//         }

//         function isWhitespace (node) {
//           return (node.isComment && !node.asyncFactory) || node.text === ' '
//         }

//         function resolveScopedSlots (
//           fns, // see flow/vnode
//           res
//         ) {
//           res = res || {}
//           for (var i = 0; i < fns.length; i++) {
//             if (Array.isArray(fns[i])) {
//               resolveScopedSlots(fns[i], res)
//             } else {
//               res[fns[i].key] = fns[i].fn
//             }
//           }
//           return res
//         }

//         /*  */

//         var activeInstance = null
//         var isUpdatingChildComponent = false

//         function initLifecycle (vm) {
//           var options = vm.$options

//           // locate first non-abstract parent
//           var parent = options.parent
//           if (parent && !options.abstract) {
//             while (parent.$options.abstract && parent.$parent) {
//               parent = parent.$parent
//             }
//             parent.$children.push(vm)
//           }

//           vm.$parent = parent
//           vm.$root = parent ? parent.$root : vm

//           vm.$children = []
//           vm.$refs = {}

//           vm._watcher = null
//           vm._inactive = null
//           vm._directInactive = false
//           vm._isMounted = false
//           vm._isDestroyed = false
//           vm._isBeingDestroyed = false
//         }

//         function lifecycleMixin (Vue) {
//           Vue.prototype._update = function (vnode, hydrating) {
//             var vm = this
//             if (vm._isMounted) {
//               callHook(vm, 'beforeUpdate')
//             }
//             var prevEl = vm.$el
//             var prevVnode = vm._vnode
//             var prevActiveInstance = activeInstance
//             activeInstance = vm
//             vm._vnode = vnode
//             // Vue.prototype.__patch__ is injected in entry points
//             // based on the rendering backend used.
//             if (!prevVnode) {
//               // initial render
//               vm.$el = vm.__patch__(
//                 vm.$el, vnode, hydrating, false /* removeOnly */,
//                 vm.$options._parentElm,
//                 vm.$options._refElm
//               )
//               // no need for the ref nodes after initial patch
//               // this prevents keeping a detached DOM tree in memory (#5851)
//               vm.$options._parentElm = vm.$options._refElm = null
//             } else {
//               // updates
//               vm.$el = vm.__patch__(prevVnode, vnode)
//             }
//             activeInstance = prevActiveInstance
//             // update __vue__ reference
//             if (prevEl) {
//               prevEl.__vue__ = null
//             }
//             if (vm.$el) {
//               vm.$el.__vue__ = vm
//             }
//             // if parent is an HOC, update its $el as well
//             if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
//               vm.$parent.$el = vm.$el
//             }
//             // updated hook is called by the scheduler to ensure that children are
//             // updated in a parent's updated hook.
//           }

//           Vue.prototype.$forceUpdate = function () {
//             var vm = this
//             if (vm._watcher) {
//               vm._watcher.update()
//             }
//           }

//           Vue.prototype.$destroy = function () {
//             var vm = this
//             if (vm._isBeingDestroyed) {
//               return
//             }
//             callHook(vm, 'beforeDestroy')
//             vm._isBeingDestroyed = true
//             // remove self from parent
//             var parent = vm.$parent
//             if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
//               remove(parent.$children, vm)
//             }
//             // teardown watchers
//             if (vm._watcher) {
//               vm._watcher.teardown()
//             }
//             var i = vm._watchers.length
//             while (i--) {
//               vm._watchers[i].teardown()
//             }
//             // remove reference from data ob
//             // frozen object may not have observer.
//             if (vm._data.__ob__) {
//               vm._data.__ob__.vmCount--
//             }
//             // call the last hook...
//             vm._isDestroyed = true
//             // invoke destroy hooks on current rendered tree
//             vm.__patch__(vm._vnode, null)
//             // fire destroyed hook
//             callHook(vm, 'destroyed')
//             // turn off all instance listeners.
//             vm.$off()
//             // remove __vue__ reference
//             if (vm.$el) {
//               vm.$el.__vue__ = null
//             }
//             // release circular reference (#6759)
//             if (vm.$vnode) {
//               vm.$vnode.parent = null
//             }
//           }
//         }

//         function mountComponent (
//           vm,
//           el,
//           hydrating
//         ) {
//           vm.$el = el
//           if (!vm.$options.render) {
//             vm.$options.render = createEmptyVNode
//             if (true) {
//               /* istanbul ignore if */
//               if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
//         vm.$options.el || el) {
//                 warn(
//                   'You are using the runtime-only build of Vue where the template ' +
//           'compiler is not available. Either pre-compile the templates into ' +
//           'render functions, or use the compiler-included build.',
//                   vm
//                 )
//               } else {
//                 warn(
//                   'Failed to mount component: template or render function not defined.',
//                   vm
//                 )
//               }
//             }
//           }
//           callHook(vm, 'beforeMount')

//           var updateComponent
//           /* istanbul ignore if */
//           if (true && config.performance && mark) {
//             updateComponent = function () {
//               var name = vm._name
//               var id = vm._uid
//               var startTag = 'vue-perf-start:' + id
//               var endTag = 'vue-perf-end:' + id

//               mark(startTag)
//               var vnode = vm._render()
//               mark(endTag)
//               measure(('vue ' + name + ' render'), startTag, endTag)

//               mark(startTag)
//               vm._update(vnode, hydrating)
//               mark(endTag)
//               measure(('vue ' + name + ' patch'), startTag, endTag)
//             }
//           } else {
//             updateComponent = function () {
//               vm._update(vm._render(), hydrating)
//             }
//           }

//           // we set this to vm._watcher inside the watcher's constructor
//           // since the watcher's initial patch may call $forceUpdate (e.g. inside child
//           // component's mounted hook), which relies on vm._watcher being already defined
//           new Watcher(vm, updateComponent, noop, null, true /* isRenderWatcher */)
//           hydrating = false

//           // manually mounted instance, call mounted on self
//           // mounted is called for render-created child components in its inserted hook
//           if (vm.$vnode == null) {
//             vm._isMounted = true
//             callHook(vm, 'mounted')
//           }
//           return vm
//         }

//         function updateChildComponent (
//           vm,
//           propsData,
//           listeners,
//           parentVnode,
//           renderChildren
//         ) {
//           if (true) {
//             isUpdatingChildComponent = true
//           }

//           // determine whether component has slot children
//           // we need to do this before overwriting $options._renderChildren
//           var hasChildren = !!(
//             renderChildren || // has new static slots
//     vm.$options._renderChildren || // has old static slots
//     parentVnode.data.scopedSlots || // has new scoped slots
//     vm.$scopedSlots !== emptyObject // has old scoped slots
//           )

//           vm.$options._parentVnode = parentVnode
//           vm.$vnode = parentVnode // update vm's placeholder node without re-render

//           if (vm._vnode) { // update child tree's parent
//             vm._vnode.parent = parentVnode
//           }
//           vm.$options._renderChildren = renderChildren

//           // update $attrs and $listeners hash
//           // these are also reactive so they may trigger child update if the child
//           // used them during render
//           vm.$attrs = (parentVnode.data && parentVnode.data.attrs) || emptyObject
//           vm.$listeners = listeners || emptyObject

//           // update props
//           if (propsData && vm.$options.props) {
//             observerState.shouldConvert = false
//             var props = vm._props
//             var propKeys = vm.$options._propKeys || []
//             for (var i = 0; i < propKeys.length; i++) {
//               var key = propKeys[i]
//               props[key] = validateProp(key, vm.$options.props, propsData, vm)
//             }
//             observerState.shouldConvert = true
//             // keep a copy of raw propsData
//             vm.$options.propsData = propsData
//           }

//           // update listeners
//           if (listeners) {
//             var oldListeners = vm.$options._parentListeners
//             vm.$options._parentListeners = listeners
//             updateComponentListeners(vm, listeners, oldListeners)
//           }
//           // resolve slots + force update if has children
//           if (hasChildren) {
//             vm.$slots = resolveSlots(renderChildren, parentVnode.context)
//             vm.$forceUpdate()
//           }

//           if (true) {
//             isUpdatingChildComponent = false
//           }
//         }

//         function isInInactiveTree (vm) {
//           while (vm && (vm = vm.$parent)) {
//             if (vm._inactive) { return true }
//           }
//           return false
//         }

//         function activateChildComponent (vm, direct) {
//           if (direct) {
//             vm._directInactive = false
//             if (isInInactiveTree(vm)) {
//               return
//             }
//           } else if (vm._directInactive) {
//             return
//           }
//           if (vm._inactive || vm._inactive === null) {
//             vm._inactive = false
//             for (var i = 0; i < vm.$children.length; i++) {
//               activateChildComponent(vm.$children[i])
//             }
//             callHook(vm, 'activated')
//           }
//         }

//         function deactivateChildComponent (vm, direct) {
//           if (direct) {
//             vm._directInactive = true
//             if (isInInactiveTree(vm)) {
//               return
//             }
//           }
//           if (!vm._inactive) {
//             vm._inactive = true
//             for (var i = 0; i < vm.$children.length; i++) {
//               deactivateChildComponent(vm.$children[i])
//             }
//             callHook(vm, 'deactivated')
//           }
//         }

//         function callHook (vm, hook) {
//           var handlers = vm.$options[hook]
//           if (handlers) {
//             for (var i = 0, j = handlers.length; i < j; i++) {
//               try {
//                 handlers[i].call(vm)
//               } catch (e) {
//                 handleError(e, vm, (hook + ' hook'))
//               }
//             }
//           }
//           if (vm._hasHookEvent) {
//             vm.$emit('hook:' + hook)
//           }
//         }

//         /*  */

//         var MAX_UPDATE_COUNT = 100

//         var queue = []
//         var activatedChildren = []
//         var has = {}
//         var circular = {}
//         var waiting = false
//         var flushing = false
//         var index = 0

//         /**
//  * Reset the scheduler's state.
//  */
//         function resetSchedulerState () {
//           index = queue.length = activatedChildren.length = 0
//           has = {}
//           if (true) {
//             circular = {}
//           }
//           waiting = flushing = false
//         }

//         /**
//  * Flush both queues and run the watchers.
//  */
//         function flushSchedulerQueue () {
//           flushing = true
//           var watcher, id

//           // Sort queue before flush.
//           // This ensures that:
//           // 1. Components are updated from parent to child. (because parent is always
//           //    created before the child)
//           // 2. A component's user watchers are run before its render watcher (because
//           //    user watchers are created before the render watcher)
//           // 3. If a component is destroyed during a parent component's watcher run,
//           //    its watchers can be skipped.
//           queue.sort(function (a, b) { return a.id - b.id })

//           // do not cache length because more watchers might be pushed
//           // as we run existing watchers
//           for (index = 0; index < queue.length; index++) {
//             watcher = queue[index]
//             id = watcher.id
//             has[id] = null
//             watcher.run()
//             // in dev build, check and stop circular updates.
//             if (true && has[id] != null) {
//               circular[id] = (circular[id] || 0) + 1
//               if (circular[id] > MAX_UPDATE_COUNT) {
//                 warn(
//                   'You may have an infinite update loop ' + (
//                     watcher.user
//                       ? ('in watcher with expression "' + (watcher.expression) + '"')
//                       : 'in a component render function.'
//                   ),
//                   watcher.vm
//                 )
//                 break
//               }
//             }
//           }

//           // keep copies of post queues before resetting state
//           var activatedQueue = activatedChildren.slice()
//           var updatedQueue = queue.slice()

//           resetSchedulerState()

//           // call component updated and activated hooks
//           callActivatedHooks(activatedQueue)
//           callUpdatedHooks(updatedQueue)

//           // devtool hook
//           /* istanbul ignore if */
//           if (devtools && config.devtools) {
//             devtools.emit('flush')
//           }
//         }

//         function callUpdatedHooks (queue) {
//           var i = queue.length
//           while (i--) {
//             var watcher = queue[i]
//             var vm = watcher.vm
//             if (vm._watcher === watcher && vm._isMounted) {
//               callHook(vm, 'updated')
//             }
//           }
//         }

//         /**
//  * Queue a kept-alive component that was activated during patch.
//  * The queue will be processed after the entire tree has been patched.
//  */
//         function queueActivatedComponent (vm) {
//           // setting _inactive to false here so that a render function can
//           // rely on checking whether it's in an inactive tree (e.g. router-view)
//           vm._inactive = false
//           activatedChildren.push(vm)
//         }

//         function callActivatedHooks (queue) {
//           for (var i = 0; i < queue.length; i++) {
//             queue[i]._inactive = true
//             activateChildComponent(queue[i], true /* true */)
//           }
//         }

//         /**
//  * Push a watcher into the watcher queue.
//  * Jobs with duplicate IDs will be skipped unless it's
//  * pushed when the queue is being flushed.
//  */
//         function queueWatcher (watcher) {
//           var id = watcher.id
//           if (has[id] == null) {
//             has[id] = true
//             if (!flushing) {
//               queue.push(watcher)
//             } else {
//               // if already flushing, splice the watcher based on its id
//               // if already past its id, it will be run next immediately.
//               var i = queue.length - 1
//               while (i > index && queue[i].id > watcher.id) {
//                 i--
//               }
//               queue.splice(i + 1, 0, watcher)
//             }
//             // queue the flush
//             if (!waiting) {
//               waiting = true
//               nextTick(flushSchedulerQueue)
//             }
//           }
//         }

//         /*  */

//         var uid$2 = 0

//         /**
//  * A watcher parses an expression, collects dependencies,
//  * and fires callback when the expression value changes.
//  * This is used for both the $watch() api and directives.
//  */
//         var Watcher = function Watcher (
//           vm,
//           expOrFn,
//           cb,
//           options,
//           isRenderWatcher
//         ) {
//           this.vm = vm
//           if (isRenderWatcher) {
//             vm._watcher = this
//           }
//           vm._watchers.push(this)
//           // options
//           if (options) {
//             this.deep = !!options.deep
//             this.user = !!options.user
//             this.lazy = !!options.lazy
//             this.sync = !!options.sync
//           } else {
//             this.deep = this.user = this.lazy = this.sync = false
//           }
//           this.cb = cb
//           this.id = ++uid$2 // uid for batching
//           this.active = true
//           this.dirty = this.lazy // for lazy watchers
//           this.deps = []
//           this.newDeps = []
//           this.depIds = new _Set()
//           this.newDepIds = new _Set()
//           this.expression = true
//             ? expOrFn.toString()
//             : undefined
//           // parse expression for getter
//           if (typeof expOrFn === 'function') {
//             this.getter = expOrFn
//           } else {
//             this.getter = parsePath(expOrFn)
//             if (!this.getter) {
//               this.getter = function () {}
//               true && warn(
//                 'Failed watching path: "' + expOrFn + '" ' +
//         'Watcher only accepts simple dot-delimited paths. ' +
//         'For full control, use a function instead.',
//                 vm
//               )
//             }
//           }
//           this.value = this.lazy
//             ? undefined
//             : this.get()
//         }

//         /**
//  * Evaluate the getter, and re-collect dependencies.
//  */
//         Watcher.prototype.get = function get () {
//           pushTarget(this)
//           var value
//           var vm = this.vm
//           try {
//             value = this.getter.call(vm, vm)
//           } catch (e) {
//             if (this.user) {
//               handleError(e, vm, ('getter for watcher "' + (this.expression) + '"'))
//             } else {
//               throw e
//             }
//           } finally {
//             // "touch" every property so they are all tracked as
//             // dependencies for deep watching
//             if (this.deep) {
//               traverse(value)
//             }
//             popTarget()
//             this.cleanupDeps()
//           }
//           return value
//         }

//         /**
//  * Add a dependency to this directive.
//  */
//         Watcher.prototype.addDep = function addDep (dep) {
//           var id = dep.id
//           if (!this.newDepIds.has(id)) {
//             this.newDepIds.add(id)
//             this.newDeps.push(dep)
//             if (!this.depIds.has(id)) {
//               dep.addSub(this)
//             }
//           }
//         }

//         /**
//  * Clean up for dependency collection.
//  */
//         Watcher.prototype.cleanupDeps = function cleanupDeps () {
//           var this$1 = this

//           var i = this.deps.length
//           while (i--) {
//             var dep = this$1.deps[i]
//             if (!this$1.newDepIds.has(dep.id)) {
//               dep.removeSub(this$1)
//             }
//           }
//           var tmp = this.depIds
//           this.depIds = this.newDepIds
//           this.newDepIds = tmp
//           this.newDepIds.clear()
//           tmp = this.deps
//           this.deps = this.newDeps
//           this.newDeps = tmp
//           this.newDeps.length = 0
//         }

//         /**
//  * Subscriber interface.
//  * Will be called when a dependency changes.
//  */
//         Watcher.prototype.update = function update () {
//           /* istanbul ignore else */
//           if (this.lazy) {
//             this.dirty = true
//           } else if (this.sync) {
//             this.run()
//           } else {
//             queueWatcher(this)
//           }
//         }

//         /**
//  * Scheduler job interface.
//  * Will be called by the scheduler.
//  */
//         Watcher.prototype.run = function run () {
//           if (this.active) {
//             var value = this.get()
//             if (
//               value !== this.value ||
//       // Deep watchers and watchers on Object/Arrays should fire even
//       // when the value is the same, because the value may
//       // have mutated.
//       isObject(value) ||
//       this.deep
//             ) {
//               // set new value
//               var oldValue = this.value
//               this.value = value
//               if (this.user) {
//                 try {
//                   this.cb.call(this.vm, value, oldValue)
//                 } catch (e) {
//                   handleError(e, this.vm, ('callback for watcher "' + (this.expression) + '"'))
//                 }
//               } else {
//                 this.cb.call(this.vm, value, oldValue)
//               }
//             }
//           }
//         }

//         /**
//  * Evaluate the value of the watcher.
//  * This only gets called for lazy watchers.
//  */
//         Watcher.prototype.evaluate = function evaluate () {
//           this.value = this.get()
//           this.dirty = false
//         }

//         /**
//  * Depend on all deps collected by this watcher.
//  */
//         Watcher.prototype.depend = function depend () {
//           var this$1 = this

//           var i = this.deps.length
//           while (i--) {
//             this$1.deps[i].depend()
//           }
//         }

//         /**
//  * Remove self from all dependencies' subscriber list.
//  */
//         Watcher.prototype.teardown = function teardown () {
//           var this$1 = this

//           if (this.active) {
//             // remove self from vm's watcher list
//             // this is a somewhat expensive operation so we skip it
//             // if the vm is being destroyed.
//             if (!this.vm._isBeingDestroyed) {
//               remove(this.vm._watchers, this)
//             }
//             var i = this.deps.length
//             while (i--) {
//               this$1.deps[i].removeSub(this$1)
//             }
//             this.active = false
//           }
//         }

//         /*  */

//         var sharedPropertyDefinition = {
//           enumerable: true,
//           configurable: true,
//           get: noop,
//           set: noop
//         }

//         function proxy (target, sourceKey, key) {
//           sharedPropertyDefinition.get = function proxyGetter () {
//             return this[sourceKey][key]
//           }
//           sharedPropertyDefinition.set = function proxySetter (val) {
//             this[sourceKey][key] = val
//           }
//           Object.defineProperty(target, key, sharedPropertyDefinition)
//         }

//         function initState (vm) {
//           vm._watchers = []
//           var opts = vm.$options
//           if (opts.props) { initProps(vm, opts.props) }
//           if (opts.methods) { initMethods(vm, opts.methods) }
//           if (opts.data) {
//             initData(vm)
//           } else {
//             observe(vm._data = {}, true /* asRootData */)
//           }
//           if (opts.computed) { initComputed(vm, opts.computed) }
//           if (opts.watch && opts.watch !== nativeWatch) {
//             initWatch(vm, opts.watch)
//           }
//         }

//         function initProps (vm, propsOptions) {
//           var propsData = vm.$options.propsData || {}
//           var props = vm._props = {}
//           // cache prop keys so that future props updates can iterate using Array
//           // instead of dynamic object key enumeration.
//           var keys = vm.$options._propKeys = []
//           var isRoot = !vm.$parent
//           // root instance props should be converted
//           observerState.shouldConvert = isRoot
//           var loop = function (key) {
//             keys.push(key)
//             var value = validateProp(key, propsOptions, propsData, vm)
//             /* istanbul ignore else */
//             if (true) {
//               var hyphenatedKey = hyphenate(key)
//               if (isReservedAttribute(hyphenatedKey) ||
//           config.isReservedAttr(hyphenatedKey)) {
//                 warn(
//                   ('"' + hyphenatedKey + '" is a reserved attribute and cannot be used as component prop.'),
//                   vm
//                 )
//               }
//               defineReactive(props, key, value, function () {
//                 if (vm.$parent && !isUpdatingChildComponent) {
//                   warn(
//                     'Avoid mutating a prop directly since the value will be ' +
//             'overwritten whenever the parent component re-renders. ' +
//             'Instead, use a data or computed property based on the prop\'s ' +
//             'value. Prop being mutated: "' + key + '"',
//                     vm
//                   )
//                 }
//               })
//             } else {}
//             // static props are already proxied on the component's prototype
//             // during Vue.extend(). We only need to proxy props defined at
//             // instantiation here.
//             if (!(key in vm)) {
//               proxy(vm, '_props', key)
//             }
//           }

//           for (var key in propsOptions) loop(key)
//           observerState.shouldConvert = true
//         }

//         function initData (vm) {
//           var data = vm.$options.data
//           data = vm._data = typeof data === 'function'
//             ? getData(data, vm)
//             : data || {}
//           if (!isPlainObject(data)) {
//             data = {}
//             true && warn(
//               'data functions should return an object:\n' +
//       'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
//               vm
//             )
//           }
//           // proxy data on instance
//           var keys = Object.keys(data)
//           var props = vm.$options.props
//           var methods = vm.$options.methods
//           var i = keys.length
//           while (i--) {
//             var key = keys[i]
//             if (true) {
//               if (methods && hasOwn(methods, key)) {
//                 warn(
//                   ('Method "' + key + '" has already been defined as a data property.'),
//                   vm
//                 )
//               }
//             }
//             if (props && hasOwn(props, key)) {
//               true && warn(
//                 'The data property "' + key + '" is already declared as a prop. ' +
//         'Use prop default value instead.',
//                 vm
//               )
//             } else if (!isReserved(key)) {
//               proxy(vm, '_data', key)
//             }
//           }
//           // observe data
//           observe(data, true /* asRootData */)
//         }

//         function getData (data, vm) {
//           try {
//             return data.call(vm, vm)
//           } catch (e) {
//             handleError(e, vm, 'data()')
//             return {}
//           }
//         }

//         var computedWatcherOptions = { lazy: true }

//         function initComputed (vm, computed) {
//           // $flow-disable-line
//           var watchers = vm._computedWatchers = Object.create(null)
//           // computed properties are just getters during SSR
//           var isSSR = isServerRendering()

//           for (var key in computed) {
//             var userDef = computed[key]
//             var getter = typeof userDef === 'function' ? userDef : userDef.get
//             if (true && getter == null) {
//               warn(
//                 ('Getter is missing for computed property "' + key + '".'),
//                 vm
//               )
//             }

//             if (!isSSR) {
//               // create internal watcher for the computed property.
//               watchers[key] = new Watcher(
//                 vm,
//                 getter || noop,
//                 noop,
//                 computedWatcherOptions
//               )
//             }

//             // component-defined computed properties are already defined on the
//             // component prototype. We only need to define computed properties defined
//             // at instantiation here.
//             if (!(key in vm)) {
//               defineComputed(vm, key, userDef)
//             } else if (true) {
//               if (key in vm.$data) {
//                 warn(('The computed property "' + key + '" is already defined in data.'), vm)
//               } else if (vm.$options.props && key in vm.$options.props) {
//                 warn(('The computed property "' + key + '" is already defined as a prop.'), vm)
//               }
//             }
//           }
//         }

//         function defineComputed (
//           target,
//           key,
//           userDef
//         ) {
//           var shouldCache = !isServerRendering()
//           if (typeof userDef === 'function') {
//             sharedPropertyDefinition.get = shouldCache
//               ? createComputedGetter(key)
//               : userDef
//             sharedPropertyDefinition.set = noop
//           } else {
//             sharedPropertyDefinition.get = userDef.get
//               ? shouldCache && userDef.cache !== false
//                 ? createComputedGetter(key)
//                 : userDef.get
//               : noop
//             sharedPropertyDefinition.set = userDef.set
//               ? userDef.set
//               : noop
//           }
//           if (true &&
//       sharedPropertyDefinition.set === noop) {
//             sharedPropertyDefinition.set = function () {
//               warn(
//                 ('Computed property "' + key + '" was assigned to but it has no setter.'),
//                 this
//               )
//             }
//           }
//           Object.defineProperty(target, key, sharedPropertyDefinition)
//         }

//         function createComputedGetter (key) {
//           return function computedGetter () {
//             var watcher = this._computedWatchers && this._computedWatchers[key]
//             if (watcher) {
//               if (watcher.dirty) {
//                 watcher.evaluate()
//               }
//               if (Dep.target) {
//                 watcher.depend()
//               }
//               return watcher.value
//             }
//           }
//         }

//         function initMethods (vm, methods) {
//           var props = vm.$options.props
//           for (var key in methods) {
//             if (true) {
//               if (methods[key] == null) {
//                 warn(
//                   'Method "' + key + '" has an undefined value in the component definition. ' +
//           'Did you reference the function correctly?',
//                   vm
//                 )
//               }
//               if (props && hasOwn(props, key)) {
//                 warn(
//                   ('Method "' + key + '" has already been defined as a prop.'),
//                   vm
//                 )
//               }
//               if ((key in vm) && isReserved(key)) {
//                 warn(
//                   'Method "' + key + '" conflicts with an existing Vue instance method. ' +
//           'Avoid defining component methods that start with _ or $.'
//                 )
//               }
//             }
//             vm[key] = methods[key] == null ? noop : bind(methods[key], vm)
//           }
//         }

//         function initWatch (vm, watch) {
//           for (var key in watch) {
//             var handler = watch[key]
//             if (Array.isArray(handler)) {
//               for (var i = 0; i < handler.length; i++) {
//                 createWatcher(vm, key, handler[i])
//               }
//             } else {
//               createWatcher(vm, key, handler)
//             }
//           }
//         }

//         function createWatcher (
//           vm,
//           keyOrFn,
//           handler,
//           options
//         ) {
//           if (isPlainObject(handler)) {
//             options = handler
//             handler = handler.handler
//           }
//           if (typeof handler === 'string') {
//             handler = vm[handler]
//           }
//           return vm.$watch(keyOrFn, handler, options)
//         }

//         function stateMixin (Vue) {
//           // flow somehow has problems with directly declared definition object
//           // when using Object.defineProperty, so we have to procedurally build up
//           // the object here.
//           var dataDef = {}
//           dataDef.get = function () { return this._data }
//           var propsDef = {}
//           propsDef.get = function () { return this._props }
//           if (true) {
//             dataDef.set = function (newData) {
//               warn(
//                 'Avoid replacing instance root $data. ' +
//         'Use nested data properties instead.',
//                 this
//               )
//             }
//             propsDef.set = function () {
//               warn('$props is readonly.', this)
//             }
//           }
//           Object.defineProperty(Vue.prototype, '$data', dataDef)
//           Object.defineProperty(Vue.prototype, '$props', propsDef)

//           Vue.prototype.$set = set
//           Vue.prototype.$delete = del

//           Vue.prototype.$watch = function (
//             expOrFn,
//             cb,
//             options
//           ) {
//             var vm = this
//             if (isPlainObject(cb)) {
//               return createWatcher(vm, expOrFn, cb, options)
//             }
//             options = options || {}
//             options.user = true
//             var watcher = new Watcher(vm, expOrFn, cb, options)
//             if (options.immediate) {
//               cb.call(vm, watcher.value)
//             }
//             return function unwatchFn () {
//               watcher.teardown()
//             }
//           }
//         }

//         /*  */

//         function initProvide (vm) {
//           var provide = vm.$options.provide
//           if (provide) {
//             vm._provided = typeof provide === 'function'
//               ? provide.call(vm)
//               : provide
//           }
//         }

//         function initInjections (vm) {
//           var result = resolveInject(vm.$options.inject, vm)
//           if (result) {
//             observerState.shouldConvert = false
//             Object.keys(result).forEach(function (key) {
//               /* istanbul ignore else */
//               if (true) {
//                 defineReactive(vm, key, result[key], function () {
//                   warn(
//                     'Avoid mutating an injected value directly since the changes will be ' +
//             'overwritten whenever the provided component re-renders. ' +
//             'injection being mutated: "' + key + '"',
//                     vm
//                   )
//                 })
//               } else {}
//             })
//             observerState.shouldConvert = true
//           }
//         }

//         function resolveInject (inject, vm) {
//           if (inject) {
//             // inject is :any because flow is not smart enough to figure out cached
//             var result = Object.create(null)
//             var keys = hasSymbol
//               ? Reflect.ownKeys(inject).filter(function (key) {
//                 /* istanbul ignore next */
//                 return Object.getOwnPropertyDescriptor(inject, key).enumerable
//               })
//               : Object.keys(inject)

//             for (var i = 0; i < keys.length; i++) {
//               var key = keys[i]
//               var provideKey = inject[key].from
//               var source = vm
//               while (source) {
//                 if (source._provided && provideKey in source._provided) {
//                   result[key] = source._provided[provideKey]
//                   break
//                 }
//                 source = source.$parent
//               }
//               if (!source) {
//                 if ('default' in inject[key]) {
//                   var provideDefault = inject[key].default
//                   result[key] = typeof provideDefault === 'function'
//                     ? provideDefault.call(vm)
//                     : provideDefault
//                 } else if (true) {
//                   warn(('Injection "' + key + '" not found'), vm)
//                 }
//               }
//             }
//             return result
//           }
//         }

//         /*  */

//         /**
//  * Runtime helper for rendering v-for lists.
//  */
//         function renderList (
//           val,
//           render
//         ) {
//           var ret, i, l, keys, key
//           if (Array.isArray(val) || typeof val === 'string') {
//             ret = new Array(val.length)
//             for (i = 0, l = val.length; i < l; i++) {
//               ret[i] = render(val[i], i)
//             }
//           } else if (typeof val === 'number') {
//             ret = new Array(val)
//             for (i = 0; i < val; i++) {
//               ret[i] = render(i + 1, i)
//             }
//           } else if (isObject(val)) {
//             keys = Object.keys(val)
//             ret = new Array(keys.length)
//             for (i = 0, l = keys.length; i < l; i++) {
//               key = keys[i]
//               ret[i] = render(val[key], key, i)
//             }
//           }
//           if (isDef(ret)) {
//             (ret)._isVList = true
//           }
//           return ret
//         }

//         /*  */

//         /**
//  * Runtime helper for rendering <slot>
//  */
//         function renderSlot (
//           name,
//           fallback,
//           props,
//           bindObject
//         ) {
//           var scopedSlotFn = this.$scopedSlots[name]
//           var nodes
//           if (scopedSlotFn) { // scoped slot
//             props = props || {}
//             if (bindObject) {
//               if (true && !isObject(bindObject)) {
//                 warn(
//                   'slot v-bind without argument expects an Object',
//                   this
//                 )
//               }
//               props = extend(extend({}, bindObject), props)
//             }
//             nodes = scopedSlotFn(props) || fallback
//           } else {
//             var slotNodes = this.$slots[name]
//             // warn duplicate slot usage
//             if (slotNodes) {
//               if (true && slotNodes._rendered) {
//                 warn(
//                   'Duplicate presence of slot "' + name + '" found in the same render tree ' +
//           '- this will likely cause render errors.',
//                   this
//                 )
//               }
//               slotNodes._rendered = true
//             }
//             nodes = slotNodes || fallback
//           }

//           var target = props && props.slot
//           if (target) {
//             return this.$createElement('template', { slot: target }, nodes)
//           } else {
//             return nodes
//           }
//         }

//         /*  */

//         /**
//  * Runtime helper for resolving filters
//  */
//         function resolveFilter (id) {
//           return resolveAsset(this.$options, 'filters', id, true) || identity
//         }

//         /*  */

//         /**
//  * Runtime helper for checking keyCodes from config.
//  * exposed as Vue.prototype._k
//  * passing in eventKeyName as last argument separately for backwards compat
//  */
//         function checkKeyCodes (
//           eventKeyCode,
//           key,
//           builtInAlias,
//           eventKeyName
//         ) {
//           var keyCodes = config.keyCodes[key] || builtInAlias
//           if (keyCodes) {
//             if (Array.isArray(keyCodes)) {
//               return keyCodes.indexOf(eventKeyCode) === -1
//             } else {
//               return keyCodes !== eventKeyCode
//             }
//           } else if (eventKeyName) {
//             return hyphenate(eventKeyName) !== key
//           }
//         }

//         /*  */

//         /**
//  * Runtime helper for merging v-bind="object" into a VNode's data.
//  */
//         function bindObjectProps (
//           data,
//           tag,
//           value,
//           asProp,
//           isSync
//         ) {
//           if (value) {
//             if (!isObject(value)) {
//               true && warn(
//                 'v-bind without argument expects an Object or Array value',
//                 this
//               )
//             } else {
//               if (Array.isArray(value)) {
//                 value = toObject(value)
//               }
//               var hash
//               var loop = function (key) {
//                 if (
//                   key === 'class' ||
//           key === 'style' ||
//           isReservedAttribute(key)
//                 ) {
//                   hash = data
//                 } else {
//                   var type = data.attrs && data.attrs.type
//                   hash = asProp || config.mustUseProp(tag, type, key)
//                     ? data.domProps || (data.domProps = {})
//                     : data.attrs || (data.attrs = {})
//                 }
//                 if (!(key in hash)) {
//                   hash[key] = value[key]

//                   if (isSync) {
//                     var on = data.on || (data.on = {})
//                     on[('update:' + key)] = function ($event) {
//                       value[key] = $event
//                     }
//                   }
//                 }
//               }

//               for (var key in value) loop(key)
//             }
//           }
//           return data
//         }

//         /*  */

//         /**
//  * Runtime helper for rendering static trees.
//  */
//         function renderStatic (
//           index,
//           isInFor
//         ) {
//           var cached = this._staticTrees || (this._staticTrees = [])
//           var tree = cached[index]
//           // if has already-rendered static tree and not inside v-for,
//           // we can reuse the same tree by doing a shallow clone.
//           if (tree && !isInFor) {
//             return Array.isArray(tree)
//               ? cloneVNodes(tree)
//               : cloneVNode(tree)
//           }
//           // otherwise, render a fresh tree.
//           tree = cached[index] = this.$options.staticRenderFns[index].call(
//             this._renderProxy,
//             null,
//             this // for render fns generated for functional component templates
//           )
//           markStatic(tree, ('__static__' + index), false)
//           return tree
//         }

//         /**
//  * Runtime helper for v-once.
//  * Effectively it means marking the node as static with a unique key.
//  */
//         function markOnce (
//           tree,
//           index,
//           key
//         ) {
//           markStatic(tree, ('__once__' + index + (key ? ('_' + key) : '')), true)
//           return tree
//         }

//         function markStatic (
//           tree,
//           key,
//           isOnce
//         ) {
//           if (Array.isArray(tree)) {
//             for (var i = 0; i < tree.length; i++) {
//               if (tree[i] && typeof tree[i] !== 'string') {
//                 markStaticNode(tree[i], (key + '_' + i), isOnce)
//               }
//             }
//           } else {
//             markStaticNode(tree, key, isOnce)
//           }
//         }

//         function markStaticNode (node, key, isOnce) {
//           node.isStatic = true
//           node.key = key
//           node.isOnce = isOnce
//         }

//         /*  */

//         function bindObjectListeners (data, value) {
//           if (value) {
//             if (!isPlainObject(value)) {
//               true && warn(
//                 'v-on without argument expects an Object value',
//                 this
//               )
//             } else {
//               var on = data.on = data.on ? extend({}, data.on) : {}
//               for (var key in value) {
//                 var existing = on[key]
//                 var ours = value[key]
//                 on[key] = existing ? [].concat(existing, ours) : ours
//               }
//             }
//           }
//           return data
//         }

//         /*  */

//         function installRenderHelpers (target) {
//           target._o = markOnce
//           target._n = toNumber
//           target._s = toString
//           target._l = renderList
//           target._t = renderSlot
//           target._q = looseEqual
//           target._i = looseIndexOf
//           target._m = renderStatic
//           target._f = resolveFilter
//           target._k = checkKeyCodes
//           target._b = bindObjectProps
//           target._v = createTextVNode
//           target._e = createEmptyVNode
//           target._u = resolveScopedSlots
//           target._g = bindObjectListeners
//         }

//         /*  */

//         function FunctionalRenderContext (
//           data,
//           props,
//           children,
//           parent,
//           Ctor
//         ) {
//           var options = Ctor.options
//           this.data = data
//           this.props = props
//           this.children = children
//           this.parent = parent
//           this.listeners = data.on || emptyObject
//           this.injections = resolveInject(options.inject, parent)
//           this.slots = function () { return resolveSlots(children, parent) }

//           // ensure the createElement function in functional components
//           // gets a unique context - this is necessary for correct named slot check
//           var contextVm = Object.create(parent)
//           var isCompiled = isTrue(options._compiled)
//           var needNormalization = !isCompiled

//           // support for compiled functional template
//           if (isCompiled) {
//             // exposing $options for renderStatic()
//             this.$options = options
//             // pre-resolve slots for renderSlot()
//             this.$slots = this.slots()
//             this.$scopedSlots = data.scopedSlots || emptyObject
//           }

//           if (options._scopeId) {
//             this._c = function (a, b, c, d) {
//               var vnode = createElement(contextVm, a, b, c, d, needNormalization)
//               if (vnode) {
//                 vnode.fnScopeId = options._scopeId
//                 vnode.fnContext = parent
//               }
//               return vnode
//             }
//           } else {
//             this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization) }
//           }
//         }

//         installRenderHelpers(FunctionalRenderContext.prototype)

//         function createFunctionalComponent (
//           Ctor,
//           propsData,
//           data,
//           contextVm,
//           children
//         ) {
//           var options = Ctor.options
//           var props = {}
//           var propOptions = options.props
//           if (isDef(propOptions)) {
//             for (var key in propOptions) {
//               props[key] = validateProp(key, propOptions, propsData || emptyObject)
//             }
//           } else {
//             if (isDef(data.attrs)) { mergeProps(props, data.attrs) }
//             if (isDef(data.props)) { mergeProps(props, data.props) }
//           }

//           var renderContext = new FunctionalRenderContext(
//             data,
//             props,
//             children,
//             contextVm,
//             Ctor
//           )

//           var vnode = options.render.call(null, renderContext._c, renderContext)

//           if (vnode instanceof VNode) {
//             vnode.fnContext = contextVm
//             vnode.fnOptions = options
//             if (data.slot) {
//               (vnode.data || (vnode.data = {})).slot = data.slot
//             }
//           }

//           return vnode
//         }

//         function mergeProps (to, from) {
//           for (var key in from) {
//             to[camelize(key)] = from[key]
//           }
//         }

//         /*  */

//         // Register the component hook to weex native render engine.
//         // The hook will be triggered by native, not javascript.

//         // Updates the state of the component to weex native render engine.

//         /*  */

//         // https://github.com/Hanks10100/weex-native-directive/tree/master/component

//         // listening on native callback

//         /*  */

//         /*  */

//         // hooks to be invoked on component VNodes during patch
//         var componentVNodeHooks = {
//           init: function init (
//             vnode,
//             hydrating,
//             parentElm,
//             refElm
//           ) {
//             if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {
//               var child = vnode.componentInstance = createComponentInstanceForVnode(
//                 vnode,
//                 activeInstance,
//                 parentElm,
//                 refElm
//               )
//               child.$mount(hydrating ? vnode.elm : undefined, hydrating)
//             } else if (vnode.data.keepAlive) {
//               // kept-alive components, treat as a patch
//               var mountedNode = vnode // work around flow
//               componentVNodeHooks.prepatch(mountedNode, mountedNode)
//             }
//           },

//           prepatch: function prepatch (oldVnode, vnode) {
//             var options = vnode.componentOptions
//             var child = vnode.componentInstance = oldVnode.componentInstance
//             updateChildComponent(
//               child,
//               options.propsData, // updated props
//               options.listeners, // updated listeners
//               vnode, // new parent vnode
//               options.children // new children
//             )
//           },

//           insert: function insert (vnode) {
//             var context = vnode.context
//             var componentInstance = vnode.componentInstance
//             if (!componentInstance._isMounted) {
//               componentInstance._isMounted = true
//               callHook(componentInstance, 'mounted')
//             }
//             if (vnode.data.keepAlive) {
//               if (context._isMounted) {
//                 // vue-router#1212
//                 // During updates, a kept-alive component's child components may
//                 // change, so directly walking the tree here may call activated hooks
//                 // on incorrect children. Instead we push them into a queue which will
//                 // be processed after the whole patch process ended.
//                 queueActivatedComponent(componentInstance)
//               } else {
//                 activateChildComponent(componentInstance, true /* direct */)
//               }
//             }
//           },

//           destroy: function destroy (vnode) {
//             var componentInstance = vnode.componentInstance
//             if (!componentInstance._isDestroyed) {
//               if (!vnode.data.keepAlive) {
//                 componentInstance.$destroy()
//               } else {
//                 deactivateChildComponent(componentInstance, true /* direct */)
//               }
//             }
//           }
//         }

//         var hooksToMerge = Object.keys(componentVNodeHooks)

//         function createComponent (
//           Ctor,
//           data,
//           context,
//           children,
//           tag
//         ) {
//           if (isUndef(Ctor)) {
//             return
//           }

//           var baseCtor = context.$options._base

//           // plain options object: turn it into a constructor
//           if (isObject(Ctor)) {
//             Ctor = baseCtor.extend(Ctor)
//           }

//           // if at this stage it's not a constructor or an async component factory,
//           // reject.
//           if (typeof Ctor !== 'function') {
//             if (true) {
//               warn(('Invalid Component definition: ' + (String(Ctor))), context)
//             }
//             return
//           }

//           // async component
//           var asyncFactory
//           if (isUndef(Ctor.cid)) {
//             asyncFactory = Ctor
//             Ctor = resolveAsyncComponent(asyncFactory, baseCtor, context)
//             if (Ctor === undefined) {
//               // return a placeholder node for async component, which is rendered
//               // as a comment node but preserves all the raw information for the node.
//               // the information will be used for async server-rendering and hydration.
//               return createAsyncPlaceholder(
//                 asyncFactory,
//                 data,
//                 context,
//                 children,
//                 tag
//               )
//             }
//           }

//           data = data || {}

//           // resolve constructor options in case global mixins are applied after
//           // component constructor creation
//           resolveConstructorOptions(Ctor)

//           // transform component v-model data into props & events
//           if (isDef(data.model)) {
//             transformModel(Ctor.options, data)
//           }

//           // extract props
//           var propsData = extractPropsFromVNodeData(data, Ctor, tag)

//           // functional component
//           if (isTrue(Ctor.options.functional)) {
//             return createFunctionalComponent(Ctor, propsData, data, context, children)
//           }

//           // extract listeners, since these needs to be treated as
//           // child component listeners instead of DOM listeners
//           var listeners = data.on
//           // replace with listeners with .native modifier
//           // so it gets processed during parent component patch.
//           data.on = data.nativeOn

//           if (isTrue(Ctor.options.abstract)) {
//             // abstract components do not keep anything
//             // other than props & listeners & slot

//             // work around flow
//             var slot = data.slot
//             data = {}
//             if (slot) {
//               data.slot = slot
//             }
//           }

//           // merge component management hooks onto the placeholder node
//           mergeHooks(data)

//           // return a placeholder vnode
//           var name = Ctor.options.name || tag
//           var vnode = new VNode(
//             ('vue-component-' + (Ctor.cid) + (name ? ('-' + name) : '')),
//             data, undefined, undefined, undefined, context,
//             { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
//             asyncFactory
//           )

//           // Weex specific: invoke recycle-list optimized @render function for
//           // extracting cell-slot template.
//           // https://github.com/Hanks10100/weex-native-directive/tree/master/component
//           /* istanbul ignore if */
//           return vnode
//         }

//         function createComponentInstanceForVnode (
//           vnode, // we know it's MountedComponentVNode but flow doesn't
//           parent, // activeInstance in lifecycle state
//           parentElm,
//           refElm
//         ) {
//           var options = {
//             _isComponent: true,
//             parent: parent,
//             _parentVnode: vnode,
//             _parentElm: parentElm || null,
//             _refElm: refElm || null
//           }
//           // check inline-template render functions
//           var inlineTemplate = vnode.data.inlineTemplate
//           if (isDef(inlineTemplate)) {
//             options.render = inlineTemplate.render
//             options.staticRenderFns = inlineTemplate.staticRenderFns
//           }
//           return new vnode.componentOptions.Ctor(options)
//         }

//         function mergeHooks (data) {
//           if (!data.hook) {
//             data.hook = {}
//           }
//           for (var i = 0; i < hooksToMerge.length; i++) {
//             var key = hooksToMerge[i]
//             var fromParent = data.hook[key]
//             var ours = componentVNodeHooks[key]
//             data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours
//           }
//         }

//         function mergeHook$1 (one, two) {
//           return function (a, b, c, d) {
//             one(a, b, c, d)
//             two(a, b, c, d)
//           }
//         }

//         // transform component v-model info (value and callback) into
//         // prop and event handler respectively.
//         function transformModel (options, data) {
//           var prop = (options.model && options.model.prop) || 'value'
//           var event = (options.model && options.model.event) || 'input'; (data.props || (data.props = {}))[prop] = data.model.value
//           var on = data.on || (data.on = {})
//           if (isDef(on[event])) {
//             on[event] = [data.model.callback].concat(on[event])
//           } else {
//             on[event] = data.model.callback
//           }
//         }

//         /*  */

//         var SIMPLE_NORMALIZE = 1
//         var ALWAYS_NORMALIZE = 2

//         // wrapper function for providing a more flexible interface
//         // without getting yelled at by flow
//         function createElement (
//           context,
//           tag,
//           data,
//           children,
//           normalizationType,
//           alwaysNormalize
//         ) {
//           if (Array.isArray(data) || isPrimitive(data)) {
//             normalizationType = children
//             children = data
//             data = undefined
//           }
//           if (isTrue(alwaysNormalize)) {
//             normalizationType = ALWAYS_NORMALIZE
//           }
//           return _createElement(context, tag, data, children, normalizationType)
//         }

//         function _createElement (
//           context,
//           tag,
//           data,
//           children,
//           normalizationType
//         ) {
//           if (isDef(data) && isDef((data).__ob__)) {
//             true && warn(
//               'Avoid using observed data object as vnode data: ' + (JSON.stringify(data)) + '\n' +
//       'Always create fresh vnode data objects in each render!',
//               context
//             )
//             return createEmptyVNode()
//           }
//           // object syntax in v-bind
//           if (isDef(data) && isDef(data.is)) {
//             tag = data.is
//           }
//           if (!tag) {
//             // in case of component :is set to falsy value
//             return createEmptyVNode()
//           }
//           // warn against non-primitive key
//           if (true &&
//     isDef(data) && isDef(data.key) && !isPrimitive(data.key)
//           ) {
//             {
//               warn(
//                 'Avoid using non-primitive value as key, ' +
//         'use string/number value instead.',
//                 context
//               )
//             }
//           }
//           // support single function children as default scoped slot
//           if (Array.isArray(children) &&
//     typeof children[0] === 'function'
//           ) {
//             data = data || {}
//             data.scopedSlots = { default: children[0] }
//             children.length = 0
//           }
//           if (normalizationType === ALWAYS_NORMALIZE) {
//             children = normalizeChildren(children)
//           } else if (normalizationType === SIMPLE_NORMALIZE) {
//             children = simpleNormalizeChildren(children)
//           }
//           var vnode, ns
//           if (typeof tag === 'string') {
//             var Ctor
//             ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag)
//             if (config.isReservedTag(tag)) {
//               // platform built-in elements
//               vnode = new VNode(
//                 config.parsePlatformTagName(tag), data, children,
//                 undefined, undefined, context
//               )
//             } else if (isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
//               // component
//               vnode = createComponent(Ctor, data, context, children, tag)
//             } else {
//               // unknown or unlisted namespaced elements
//               // check at runtime because it may get assigned a namespace when its
//               // parent normalizes children
//               vnode = new VNode(
//                 tag, data, children,
//                 undefined, undefined, context
//               )
//             }
//           } else {
//             // direct component options / constructor
//             vnode = createComponent(tag, data, context, children)
//           }
//           if (isDef(vnode)) {
//             if (ns) { applyNS(vnode, ns) }
//             return vnode
//           } else {
//             return createEmptyVNode()
//           }
//         }

//         function applyNS (vnode, ns, force) {
//           vnode.ns = ns
//           if (vnode.tag === 'foreignObject') {
//             // use default namespace inside foreignObject
//             ns = undefined
//             force = true
//           }
//           if (isDef(vnode.children)) {
//             for (var i = 0, l = vnode.children.length; i < l; i++) {
//               var child = vnode.children[i]
//               if (isDef(child.tag) && (isUndef(child.ns) || isTrue(force))) {
//                 applyNS(child, ns, force)
//               }
//             }
//           }
//         }

//         /*  */

//         function initRender (vm) {
//           vm._vnode = null // the root of the child tree
//           vm._staticTrees = null // v-once cached trees
//           var options = vm.$options
//           var parentVnode = vm.$vnode = options._parentVnode // the placeholder node in parent tree
//           var renderContext = parentVnode && parentVnode.context
//           vm.$slots = resolveSlots(options._renderChildren, renderContext)
//           vm.$scopedSlots = emptyObject
//           // bind the createElement fn to this instance
//           // so that we get proper render context inside it.
//           // args order: tag, data, children, normalizationType, alwaysNormalize
//           // internal version is used by render functions compiled from templates
//           vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false) }
//           // normalization is always applied for the public version, used in
//           // user-written render functions.
//           vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true) }

//           // $attrs & $listeners are exposed for easier HOC creation.
//           // they need to be reactive so that HOCs using them are always updated
//           var parentData = parentVnode && parentVnode.data

//           /* istanbul ignore else */
//           if (true) {
//             defineReactive(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
//               !isUpdatingChildComponent && warn('$attrs is readonly.', vm)
//             }, true)
//             defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
//               !isUpdatingChildComponent && warn('$listeners is readonly.', vm)
//             }, true)
//           } else {}
//         }

//         function renderMixin (Vue) {
//           // install runtime convenience helpers
//           installRenderHelpers(Vue.prototype)

//           Vue.prototype.$nextTick = function (fn) {
//             return nextTick(fn, this)
//           }

//           Vue.prototype._render = function () {
//             var vm = this
//             var ref = vm.$options
//             var render = ref.render
//             var _parentVnode = ref._parentVnode

//             if (vm._isMounted) {
//               // if the parent didn't update, the slot nodes will be the ones from
//               // last render. They need to be cloned to ensure "freshness" for this render.
//               for (var key in vm.$slots) {
//                 var slot = vm.$slots[key]
//                 // _rendered is a flag added by renderSlot, but may not be present
//                 // if the slot is passed from manually written render functions
//                 if (slot._rendered || (slot[0] && slot[0].elm)) {
//                   vm.$slots[key] = cloneVNodes(slot, true /* deep */)
//                 }
//               }
//             }

//             vm.$scopedSlots = (_parentVnode && _parentVnode.data.scopedSlots) || emptyObject

//             // set parent vnode. this allows render functions to have access
//             // to the data on the placeholder node.
//             vm.$vnode = _parentVnode
//             // render self
//             var vnode
//             try {
//               vnode = render.call(vm._renderProxy, vm.$createElement)
//             } catch (e) {
//               handleError(e, vm, 'render')
//               // return error render result,
//               // or previous vnode to prevent render error causing blank component
//               /* istanbul ignore else */
//               if (true) {
//                 if (vm.$options.renderError) {
//                   try {
//                     vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e)
//                   } catch (e) {
//                     handleError(e, vm, 'renderError')
//                     vnode = vm._vnode
//                   }
//                 } else {
//                   vnode = vm._vnode
//                 }
//               } else {}
//             }
//             // return empty vnode in case the render function errored out
//             if (!(vnode instanceof VNode)) {
//               if (true && Array.isArray(vnode)) {
//                 warn(
//                   'Multiple root nodes returned from render function. Render function ' +
//           'should return a single root node.',
//                   vm
//                 )
//               }
//               vnode = createEmptyVNode()
//             }
//             // set parent
//             vnode.parent = _parentVnode
//             return vnode
//           }
//         }

//         /*  */

//         var uid = 0

//         function initMixin (Vue) {
//           Vue.prototype._init = function (options) {
//             var vm = this
//             // a uid
//             vm._uid = uid++

//             var startTag, endTag
//             /* istanbul ignore if */
//             if (true && config.performance && mark) {
//               startTag = 'vue-perf-start:' + (vm._uid)
//               endTag = 'vue-perf-end:' + (vm._uid)
//               mark(startTag)
//             }

//             // a flag to avoid this being observed
//             vm._isVue = true
//             // merge options
//             if (options && options._isComponent) {
//               // optimize internal component instantiation
//               // since dynamic options merging is pretty slow, and none of the
//               // internal component options needs special treatment.
//               initInternalComponent(vm, options)
//             } else {
//               vm.$options = mergeOptions(
//                 resolveConstructorOptions(vm.constructor),
//                 options || {},
//                 vm
//               )
//             }
//             /* istanbul ignore else */
//             if (true) {
//               initProxy(vm)
//             } else {}
//             // expose real self
//             vm._self = vm
//             initLifecycle(vm)
//             initEvents(vm)
//             initRender(vm)
//             callHook(vm, 'beforeCreate')
//             initInjections(vm) // resolve injections before data/props
//             initState(vm)
//             initProvide(vm) // resolve provide after data/props
//             callHook(vm, 'created')

//             /* istanbul ignore if */
//             if (true && config.performance && mark) {
//               vm._name = formatComponentName(vm, false)
//               mark(endTag)
//               measure(('vue ' + (vm._name) + ' init'), startTag, endTag)
//             }

//             if (vm.$options.el) {
//               vm.$mount(vm.$options.el)
//             }
//           }
//         }

//         function initInternalComponent (vm, options) {
//           var opts = vm.$options = Object.create(vm.constructor.options)
//           // doing this because it's faster than dynamic enumeration.
//           var parentVnode = options._parentVnode
//           opts.parent = options.parent
//           opts._parentVnode = parentVnode
//           opts._parentElm = options._parentElm
//           opts._refElm = options._refElm

//           var vnodeComponentOptions = parentVnode.componentOptions
//           opts.propsData = vnodeComponentOptions.propsData
//           opts._parentListeners = vnodeComponentOptions.listeners
//           opts._renderChildren = vnodeComponentOptions.children
//           opts._componentTag = vnodeComponentOptions.tag

//           if (options.render) {
//             opts.render = options.render
//             opts.staticRenderFns = options.staticRenderFns
//           }
//         }

//         function resolveConstructorOptions (Ctor) {
//           var options = Ctor.options
//           if (Ctor.super) {
//             var superOptions = resolveConstructorOptions(Ctor.super)
//             var cachedSuperOptions = Ctor.superOptions
//             if (superOptions !== cachedSuperOptions) {
//               // super option changed,
//               // need to resolve new options.
//               Ctor.superOptions = superOptions
//               // check if there are any late-modified/attached options (#4976)
//               var modifiedOptions = resolveModifiedOptions(Ctor)
//               // update base extend options
//               if (modifiedOptions) {
//                 extend(Ctor.extendOptions, modifiedOptions)
//               }
//               options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions)
//               if (options.name) {
//                 options.components[options.name] = Ctor
//               }
//             }
//           }
//           return options
//         }

//         function resolveModifiedOptions (Ctor) {
//           var modified
//           var latest = Ctor.options
//           var extended = Ctor.extendOptions
//           var sealed = Ctor.sealedOptions
//           for (var key in latest) {
//             if (latest[key] !== sealed[key]) {
//               if (!modified) { modified = {} }
//               modified[key] = dedupe(latest[key], extended[key], sealed[key])
//             }
//           }
//           return modified
//         }

//         function dedupe (latest, extended, sealed) {
//           // compare latest and sealed to ensure lifecycle hooks won't be duplicated
//           // between merges
//           if (Array.isArray(latest)) {
//             var res = []
//             sealed = Array.isArray(sealed) ? sealed : [sealed]
//             extended = Array.isArray(extended) ? extended : [extended]
//             for (var i = 0; i < latest.length; i++) {
//               // push original options and not sealed options to exclude duplicated options
//               if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) {
//                 res.push(latest[i])
//               }
//             }
//             return res
//           } else {
//             return latest
//           }
//         }

//         function Vue$3 (options) {
//           if (true &&
//     !(this instanceof Vue$3)
//           ) {
//             warn('Vue is a constructor and should be called with the `new` keyword')
//           }
//           this._init(options)
//         }

//         initMixin(Vue$3)
//         stateMixin(Vue$3)
//         eventsMixin(Vue$3)
//         lifecycleMixin(Vue$3)
//         renderMixin(Vue$3)

//         /*  */

//         function initUse (Vue) {
//           Vue.use = function (plugin) {
//             var installedPlugins = (this._installedPlugins || (this._installedPlugins = []))
//             if (installedPlugins.indexOf(plugin) > -1) {
//               return this
//             }

//             // additional parameters
//             var args = toArray(arguments, 1)
//             args.unshift(this)
//             if (typeof plugin.install === 'function') {
//               plugin.install.apply(plugin, args)
//             } else if (typeof plugin === 'function') {
//               plugin.apply(null, args)
//             }
//             installedPlugins.push(plugin)
//             return this
//           }
//         }

//         /*  */

//         function initMixin$1 (Vue) {
//           Vue.mixin = function (mixin) {
//             this.options = mergeOptions(this.options, mixin)
//             return this
//           }
//         }

//         /*  */

//         function initExtend (Vue) {
//           /**
//    * Each instance constructor, including Vue, has a unique
//    * cid. This enables us to create wrapped "child
//    * constructors" for prototypal inheritance and cache them.
//    */
//           Vue.cid = 0
//           var cid = 1

//           /**
//    * Class inheritance
//    */
//           Vue.extend = function (extendOptions) {
//             extendOptions = extendOptions || {}
//             var Super = this
//             var SuperId = Super.cid
//             var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {})
//             if (cachedCtors[SuperId]) {
//               return cachedCtors[SuperId]
//             }

//             var name = extendOptions.name || Super.options.name
//             if (true && name) {
//               validateComponentName(name)
//             }

//             var Sub = function VueComponent (options) {
//               this._init(options)
//             }
//             Sub.prototype = Object.create(Super.prototype)
//             Sub.prototype.constructor = Sub
//             Sub.cid = cid++
//             Sub.options = mergeOptions(
//               Super.options,
//               extendOptions
//             )
//             Sub['super'] = Super

//             // For props and computed properties, we define the proxy getters on
//             // the Vue instances at extension time, on the extended prototype. This
//             // avoids Object.defineProperty calls for each instance created.
//             if (Sub.options.props) {
//               initProps$1(Sub)
//             }
//             if (Sub.options.computed) {
//               initComputed$1(Sub)
//             }

//             // allow further extension/mixin/plugin usage
//             Sub.extend = Super.extend
//             Sub.mixin = Super.mixin
//             Sub.use = Super.use

//             // create asset registers, so extended classes
//             // can have their private assets too.
//             ASSET_TYPES.forEach(function (type) {
//               Sub[type] = Super[type]
//             })
//             // enable recursive self-lookup
//             if (name) {
//               Sub.options.components[name] = Sub
//             }

//             // keep a reference to the super options at extension time.
//             // later at instantiation we can check if Super's options have
//             // been updated.
//             Sub.superOptions = Super.options
//             Sub.extendOptions = extendOptions
//             Sub.sealedOptions = extend({}, Sub.options)

//             // cache constructor
//             cachedCtors[SuperId] = Sub
//             return Sub
//           }
//         }

//         function initProps$1 (Comp) {
//           var props = Comp.options.props
//           for (var key in props) {
//             proxy(Comp.prototype, '_props', key)
//           }
//         }

//         function initComputed$1 (Comp) {
//           var computed = Comp.options.computed
//           for (var key in computed) {
//             defineComputed(Comp.prototype, key, computed[key])
//           }
//         }

//         /*  */

//         function initAssetRegisters (Vue) {
//           /**
//    * Create asset registration methods.
//    */
//           ASSET_TYPES.forEach(function (type) {
//             Vue[type] = function (
//               id,
//               definition
//             ) {
//               if (!definition) {
//                 return this.options[type + 's'][id]
//               } else {
//                 /* istanbul ignore if */
//                 if (true && type === 'component') {
//                   validateComponentName(id)
//                 }
//                 if (type === 'component' && isPlainObject(definition)) {
//                   definition.name = definition.name || id
//                   definition = this.options._base.extend(definition)
//                 }
//                 if (type === 'directive' && typeof definition === 'function') {
//                   definition = { bind: definition, update: definition }
//                 }
//                 this.options[type + 's'][id] = definition
//                 return definition
//               }
//             }
//           })
//         }

//         /*  */

//         function getComponentName (opts) {
//           return opts && (opts.Ctor.options.name || opts.tag)
//         }

//         function matches (pattern, name) {
//           if (Array.isArray(pattern)) {
//             return pattern.indexOf(name) > -1
//           } else if (typeof pattern === 'string') {
//             return pattern.split(',').indexOf(name) > -1
//           } else if (isRegExp(pattern)) {
//             return pattern.test(name)
//           }
//           /* istanbul ignore next */
//           return false
//         }

//         function pruneCache (keepAliveInstance, filter) {
//           var cache = keepAliveInstance.cache
//           var keys = keepAliveInstance.keys
//           var _vnode = keepAliveInstance._vnode
//           for (var key in cache) {
//             var cachedNode = cache[key]
//             if (cachedNode) {
//               var name = getComponentName(cachedNode.componentOptions)
//               if (name && !filter(name)) {
//                 pruneCacheEntry(cache, key, keys, _vnode)
//               }
//             }
//           }
//         }

//         function pruneCacheEntry (
//           cache,
//           key,
//           keys,
//           current
//         ) {
//           var cached$$1 = cache[key]
//           if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
//             cached$$1.componentInstance.$destroy()
//           }
//           cache[key] = null
//           remove(keys, key)
//         }

//         var patternTypes = [String, RegExp, Array]

//         var KeepAlive = {
//           name: 'keep-alive',
//           abstract: true,

//           props: {
//             include: patternTypes,
//             exclude: patternTypes,
//             max: [String, Number]
//           },

//           created: function created () {
//             this.cache = Object.create(null)
//             this.keys = []
//           },

//           destroyed: function destroyed () {
//             var this$1 = this

//             for (var key in this$1.cache) {
//               pruneCacheEntry(this$1.cache, key, this$1.keys)
//             }
//           },

//           watch: {
//             include: function include (val) {
//               pruneCache(this, function (name) { return matches(val, name) })
//             },
//             exclude: function exclude (val) {
//               pruneCache(this, function (name) { return !matches(val, name) })
//             }
//           },

//           render: function render () {
//             var slot = this.$slots.default
//             var vnode = getFirstComponentChild(slot)
//             var componentOptions = vnode && vnode.componentOptions
//             if (componentOptions) {
//               // check pattern
//               var name = getComponentName(componentOptions)
//               var ref = this
//               var include = ref.include
//               var exclude = ref.exclude
//               if (
//               // not included
//                 (include && (!name || !matches(include, name))) ||
//         // excluded
//         (exclude && name && matches(exclude, name))
//               ) {
//                 return vnode
//               }

//               var ref$1 = this
//               var cache = ref$1.cache
//               var keys = ref$1.keys
//               var key = vnode.key == null
//               // same constructor may get registered as different local components
//               // so cid alone is not enough (#3269)
//                 ? componentOptions.Ctor.cid + (componentOptions.tag ? ('::' + (componentOptions.tag)) : '')
//                 : vnode.key
//               if (cache[key]) {
//                 vnode.componentInstance = cache[key].componentInstance
//                 // make current key freshest
//                 remove(keys, key)
//                 keys.push(key)
//               } else {
//                 cache[key] = vnode
//                 keys.push(key)
//                 // prune oldest entry
//                 if (this.max && keys.length > parseInt(this.max)) {
//                   pruneCacheEntry(cache, keys[0], keys, this._vnode)
//                 }
//               }

//               vnode.data.keepAlive = true
//             }
//             return vnode || (slot && slot[0])
//           }
//         }

//         var builtInComponents = {
//           KeepAlive: KeepAlive
//         }

//         /*  */

//         function initGlobalAPI (Vue) {
//           // config
//           var configDef = {}
//           configDef.get = function () { return config }
//           if (true) {
//             configDef.set = function () {
//               warn(
//                 'Do not replace the Vue.config object, set individual fields instead.'
//               )
//             }
//           }
//           Object.defineProperty(Vue, 'config', configDef)

//           // exposed util methods.
//           // NOTE: these are not considered part of the public API - avoid relying on
//           // them unless you are aware of the risk.
//           Vue.util = {
//             warn: warn,
//             extend: extend,
//             mergeOptions: mergeOptions,
//             defineReactive: defineReactive
//           }

//           Vue.set = set
//           Vue.delete = del
//           Vue.nextTick = nextTick

//           Vue.options = Object.create(null)
//           ASSET_TYPES.forEach(function (type) {
//             Vue.options[type + 's'] = Object.create(null)
//           })

//           // this is used to identify the "base" constructor to extend all plain-object
//           // components with in Weex's multi-instance scenarios.
//           Vue.options._base = Vue

//           extend(Vue.options.components, builtInComponents)

//           initUse(Vue)
//           initMixin$1(Vue)
//           initExtend(Vue)
//           initAssetRegisters(Vue)
//         }

//         initGlobalAPI(Vue$3)

//         Object.defineProperty(Vue$3.prototype, '$isServer', {
//           get: isServerRendering
//         })

//         Object.defineProperty(Vue$3.prototype, '$ssrContext', {
//           get: function get () {
//             /* istanbul ignore next */
//             return this.$vnode && this.$vnode.ssrContext
//           }
//         })

//         Vue$3.version = '2.5.13'

//         /*  */

//         // these are reserved for web because they are directly compiled away
//         // during template compilation
//         var isReservedAttr = makeMap('style,class')

//         // attributes that should be using props for binding
//         var acceptValue = makeMap('input,textarea,option,select,progress')
//         var mustUseProp = function (tag, type, attr) {
//           return (
//             (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
//     (attr === 'selected' && tag === 'option') ||
//     (attr === 'checked' && tag === 'input') ||
//     (attr === 'muted' && tag === 'video')
//           )
//         }

//         var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck')

//         var isBooleanAttr = makeMap(
//           'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
//   'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
//   'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
//   'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
//   'required,reversed,scoped,seamless,selected,sortable,translate,' +
//   'truespeed,typemustmatch,visible'
//         )

//         var xlinkNS = 'http://www.w3.org/1999/xlink'

//         var isXlink = function (name) {
//           return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
//         }

//         var getXlinkProp = function (name) {
//           return isXlink(name) ? name.slice(6, name.length) : ''
//         }

//         var isFalsyAttrValue = function (val) {
//           return val == null || val === false
//         }

//         /*  */

//         function genClassForVnode (vnode) {
//           var data = vnode.data
//           var parentNode = vnode
//           var childNode = vnode
//           while (isDef(childNode.componentInstance)) {
//             childNode = childNode.componentInstance._vnode
//             if (childNode && childNode.data) {
//               data = mergeClassData(childNode.data, data)
//             }
//           }
//           while (isDef(parentNode = parentNode.parent)) {
//             if (parentNode && parentNode.data) {
//               data = mergeClassData(data, parentNode.data)
//             }
//           }
//           return renderClass(data.staticClass, data.class)
//         }

//         function mergeClassData (child, parent) {
//           return {
//             staticClass: concat(child.staticClass, parent.staticClass),
//             class: isDef(child.class)
//               ? [child.class, parent.class]
//               : parent.class
//           }
//         }

//         function renderClass (
//           staticClass,
//           dynamicClass
//         ) {
//           if (isDef(staticClass) || isDef(dynamicClass)) {
//             return concat(staticClass, stringifyClass(dynamicClass))
//           }
//           /* istanbul ignore next */
//           return ''
//         }

//         function concat (a, b) {
//           return a ? b ? (a + ' ' + b) : a : (b || '')
//         }

//         function stringifyClass (value) {
//           if (Array.isArray(value)) {
//             return stringifyArray(value)
//           }
//           if (isObject(value)) {
//             return stringifyObject(value)
//           }
//           if (typeof value === 'string') {
//             return value
//           }
//           /* istanbul ignore next */
//           return ''
//         }

//         function stringifyArray (value) {
//           var res = ''
//           var stringified
//           for (var i = 0, l = value.length; i < l; i++) {
//             if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
//               if (res) { res += ' ' }
//               res += stringified
//             }
//           }
//           return res
//         }

//         function stringifyObject (value) {
//           var res = ''
//           for (var key in value) {
//             if (value[key]) {
//               if (res) { res += ' ' }
//               res += key
//             }
//           }
//           return res
//         }

//         /*  */

//         var namespaceMap = {
//           svg: 'http://www.w3.org/2000/svg',
//           math: 'http://www.w3.org/1998/Math/MathML'
//         }

//         var isHTMLTag = makeMap(
//           'html,body,base,head,link,meta,style,title,' +
//   'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
//   'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
//   'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
//   's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
//   'embed,object,param,source,canvas,script,noscript,del,ins,' +
//   'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
//   'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
//   'output,progress,select,textarea,' +
//   'details,dialog,menu,menuitem,summary,' +
//   'content,element,shadow,template,blockquote,iframe,tfoot'
//         )

//         // this map is intentionally selective, only covering SVG elements that may
//         // contain child elements.
//         var isSVG = makeMap(
//           'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
//   'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
//   'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
//           true
//         )

//         var isReservedTag = function (tag) {
//           return isHTMLTag(tag) || isSVG(tag)
//         }

//         function getTagNamespace (tag) {
//           if (isSVG(tag)) {
//             return 'svg'
//           }
//           // basic support for MathML
//           // note it doesn't support other MathML elements being component roots
//           if (tag === 'math') {
//             return 'math'
//           }
//         }

//         var unknownElementCache = Object.create(null)
//         function isUnknownElement (tag) {
//           /* istanbul ignore if */
//           if (!inBrowser) {
//             return true
//           }
//           if (isReservedTag(tag)) {
//             return false
//           }
//           tag = tag.toLowerCase()
//           /* istanbul ignore if */
//           if (unknownElementCache[tag] != null) {
//             return unknownElementCache[tag]
//           }
//           var el = document.createElement(tag)
//           if (tag.indexOf('-') > -1) {
//             // http://stackoverflow.com/a/28210364/1070244
//             return (unknownElementCache[tag] = (
//               el.constructor === window.HTMLUnknownElement ||
//       el.constructor === window.HTMLElement
//             ))
//           } else {
//             return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
//           }
//         }

//         var isTextInputType = makeMap('text,number,password,search,email,tel,url')

//         /*  */

//         /**
//  * Query an element selector if it's not an element already.
//  */
//         function query (el) {
//           if (typeof el === 'string') {
//             var selected = document.querySelector(el)
//             if (!selected) {
//               true && warn(
//                 'Cannot find element: ' + el
//               )
//               return document.createElement('div')
//             }
//             return selected
//           } else {
//             return el
//           }
//         }

//         /*  */

//         function createElement$1 (tagName, vnode) {
//           var elm = document.createElement(tagName)
//           if (tagName !== 'select') {
//             return elm
//           }
//           // false or null will remove the attribute but undefined will not
//           if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
//             elm.setAttribute('multiple', 'multiple')
//           }
//           return elm
//         }

//         function createElementNS (namespace, tagName) {
//           return document.createElementNS(namespaceMap[namespace], tagName)
//         }

//         function createTextNode (text) {
//           return document.createTextNode(text)
//         }

//         function createComment (text) {
//           return document.createComment(text)
//         }

//         function insertBefore (parentNode, newNode, referenceNode) {
//           parentNode.insertBefore(newNode, referenceNode)
//         }

//         function removeChild (node, child) {
//           node.removeChild(child)
//         }

//         function appendChild (node, child) {
//           node.appendChild(child)
//         }

//         function parentNode (node) {
//           return node.parentNode
//         }

//         function nextSibling (node) {
//           return node.nextSibling
//         }

//         function tagName (node) {
//           return node.tagName
//         }

//         function setTextContent (node, text) {
//           node.textContent = text
//         }

//         function setAttribute (node, key, val) {
//           node.setAttribute(key, val)
//         }

//         var nodeOps = Object.freeze({
//           createElement: createElement$1,
//           createElementNS: createElementNS,
//           createTextNode: createTextNode,
//           createComment: createComment,
//           insertBefore: insertBefore,
//           removeChild: removeChild,
//           appendChild: appendChild,
//           parentNode: parentNode,
//           nextSibling: nextSibling,
//           tagName: tagName,
//           setTextContent: setTextContent,
//           setAttribute: setAttribute
//         })

//         /*  */

//         var ref = {
//           create: function create (_, vnode) {
//             registerRef(vnode)
//           },
//           update: function update (oldVnode, vnode) {
//             if (oldVnode.data.ref !== vnode.data.ref) {
//               registerRef(oldVnode, true)
//               registerRef(vnode)
//             }
//           },
//           destroy: function destroy (vnode) {
//             registerRef(vnode, true)
//           }
//         }

//         function registerRef (vnode, isRemoval) {
//           var key = vnode.data.ref
//           if (!key) { return }

//           var vm = vnode.context
//           var ref = vnode.componentInstance || vnode.elm
//           var refs = vm.$refs
//           if (isRemoval) {
//             if (Array.isArray(refs[key])) {
//               remove(refs[key], ref)
//             } else if (refs[key] === ref) {
//               refs[key] = undefined
//             }
//           } else {
//             if (vnode.data.refInFor) {
//               if (!Array.isArray(refs[key])) {
//                 refs[key] = [ref]
//               } else if (refs[key].indexOf(ref) < 0) {
//                 // $flow-disable-line
//                 refs[key].push(ref)
//               }
//             } else {
//               refs[key] = ref
//             }
//           }
//         }

//         /**
//  * Virtual DOM patching algorithm based on Snabbdom by
//  * Simon Friis Vindum (@paldepind)
//  * Licensed under the MIT License
//  * https://github.com/paldepind/snabbdom/blob/master/LICENSE
//  *
//  * modified by Evan You (@yyx990803)
//  *
//  * Not type-checking this because this file is perf-critical and the cost
//  * of making flow understand it is not worth it.
//  */

//         var emptyNode = new VNode('', {}, [])

//         var hooks = ['create', 'activate', 'update', 'remove', 'destroy']

//         function sameVnode (a, b) {
//           return (
//             a.key === b.key && (
//               (
//                 a.tag === b.tag &&
//         a.isComment === b.isComment &&
//         isDef(a.data) === isDef(b.data) &&
//         sameInputType(a, b)
//               ) || (
//                 isTrue(a.isAsyncPlaceholder) &&
//         a.asyncFactory === b.asyncFactory &&
//         isUndef(b.asyncFactory.error)
//               )
//             )
//           )
//         }

//         function sameInputType (a, b) {
//           if (a.tag !== 'input') { return true }
//           var i
//           var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type
//           var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type
//           return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
//         }

//         function createKeyToOldIdx (children, beginIdx, endIdx) {
//           var i, key
//           var map = {}
//           for (i = beginIdx; i <= endIdx; ++i) {
//             key = children[i].key
//             if (isDef(key)) { map[key] = i }
//           }
//           return map
//         }

//         function createPatchFunction (backend) {
//           var i, j
//           var cbs = {}

//           var modules = backend.modules
//           var nodeOps = backend.nodeOps

//           for (i = 0; i < hooks.length; ++i) {
//             cbs[hooks[i]] = []
//             for (j = 0; j < modules.length; ++j) {
//               if (isDef(modules[j][hooks[i]])) {
//                 cbs[hooks[i]].push(modules[j][hooks[i]])
//               }
//             }
//           }

//           function emptyNodeAt (elm) {
//             return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
//           }

//           function createRmCb (childElm, listeners) {
//             function remove () {
//               if (--remove.listeners === 0) {
//                 removeNode(childElm)
//               }
//             }
//             remove.listeners = listeners
//             return remove
//           }

//           function removeNode (el) {
//             var parent = nodeOps.parentNode(el)
//             // element may have already been removed due to v-html / v-text
//             if (isDef(parent)) {
//               nodeOps.removeChild(parent, el)
//             }
//           }

//           function isUnknownElement$$1 (vnode, inVPre) {
//             return (
//               !inVPre &&
//       !vnode.ns &&
//       !(
//         config.ignoredElements.length &&
//         config.ignoredElements.some(function (ignore) {
//           return isRegExp(ignore)
//             ? ignore.test(vnode.tag)
//             : ignore === vnode.tag
//         })
//       ) &&
//       config.isUnknownElement(vnode.tag)
//             )
//           }

//           var creatingElmInVPre = 0
//           function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {
//             vnode.isRootInsert = !nested // for transition enter check
//             if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
//               return
//             }

//             var data = vnode.data
//             var children = vnode.children
//             var tag = vnode.tag
//             if (isDef(tag)) {
//               if (true) {
//                 if (data && data.pre) {
//                   creatingElmInVPre++
//                 }
//                 if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
//                   warn(
//                     'Unknown custom element: <' + tag + '> - did you ' +
//             'register the component correctly? For recursive components, ' +
//             'make sure to provide the "name" option.',
//                     vnode.context
//                   )
//                 }
//               }
//               vnode.elm = vnode.ns
//                 ? nodeOps.createElementNS(vnode.ns, tag)
//                 : nodeOps.createElement(tag, vnode)
//               setScope(vnode)

//               /* istanbul ignore if */
//               {
//                 createChildren(vnode, children, insertedVnodeQueue)
//                 if (isDef(data)) {
//                   invokeCreateHooks(vnode, insertedVnodeQueue)
//                 }
//                 insert(parentElm, vnode.elm, refElm)
//               }

//               if (true && data && data.pre) {
//                 creatingElmInVPre--
//               }
//             } else if (isTrue(vnode.isComment)) {
//               vnode.elm = nodeOps.createComment(vnode.text)
//               insert(parentElm, vnode.elm, refElm)
//             } else {
//               vnode.elm = nodeOps.createTextNode(vnode.text)
//               insert(parentElm, vnode.elm, refElm)
//             }
//           }

//           function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
//             var i = vnode.data
//             if (isDef(i)) {
//               var isReactivated = isDef(vnode.componentInstance) && i.keepAlive
//               if (isDef(i = i.hook) && isDef(i = i.init)) {
//                 i(vnode, false /* hydrating */, parentElm, refElm)
//               }
//               // after calling the init hook, if the vnode is a child component
//               // it should've created a child instance and mounted it. the child
//               // component also has set the placeholder vnode's elm.
//               // in that case we can just return the element and be done.
//               if (isDef(vnode.componentInstance)) {
//                 initComponent(vnode, insertedVnodeQueue)
//                 if (isTrue(isReactivated)) {
//                   reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm)
//                 }
//                 return true
//               }
//             }
//           }

//           function initComponent (vnode, insertedVnodeQueue) {
//             if (isDef(vnode.data.pendingInsert)) {
//               insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert)
//               vnode.data.pendingInsert = null
//             }
//             vnode.elm = vnode.componentInstance.$el
//             if (isPatchable(vnode)) {
//               invokeCreateHooks(vnode, insertedVnodeQueue)
//               setScope(vnode)
//             } else {
//               // empty component root.
//               // skip all element-related modules except for ref (#3455)
//               registerRef(vnode)
//               // make sure to invoke the insert hook
//               insertedVnodeQueue.push(vnode)
//             }
//           }

//           function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
//             var i
//             // hack for #4339: a reactivated component with inner transition
//             // does not trigger because the inner node's created hooks are not called
//             // again. It's not ideal to involve module-specific logic in here but
//             // there doesn't seem to be a better way to do it.
//             var innerNode = vnode
//             while (innerNode.componentInstance) {
//               innerNode = innerNode.componentInstance._vnode
//               if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
//                 for (i = 0; i < cbs.activate.length; ++i) {
//                   cbs.activate[i](emptyNode, innerNode)
//                 }
//                 insertedVnodeQueue.push(innerNode)
//                 break
//               }
//             }
//             // unlike a newly created component,
//             // a reactivated keep-alive component doesn't insert itself
//             insert(parentElm, vnode.elm, refElm)
//           }

//           function insert (parent, elm, ref$$1) {
//             if (isDef(parent)) {
//               if (isDef(ref$$1)) {
//                 if (ref$$1.parentNode === parent) {
//                   nodeOps.insertBefore(parent, elm, ref$$1)
//                 }
//               } else {
//                 nodeOps.appendChild(parent, elm)
//               }
//             }
//           }

//           function createChildren (vnode, children, insertedVnodeQueue) {
//             if (Array.isArray(children)) {
//               if (true) {
//                 checkDuplicateKeys(children)
//               }
//               for (var i = 0; i < children.length; ++i) {
//                 createElm(children[i], insertedVnodeQueue, vnode.elm, null, true)
//               }
//             } else if (isPrimitive(vnode.text)) {
//               nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)))
//             }
//           }

//           function isPatchable (vnode) {
//             while (vnode.componentInstance) {
//               vnode = vnode.componentInstance._vnode
//             }
//             return isDef(vnode.tag)
//           }

//           function invokeCreateHooks (vnode, insertedVnodeQueue) {
//             for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
//               cbs.create[i$1](emptyNode, vnode)
//             }
//             i = vnode.data.hook // Reuse variable
//             if (isDef(i)) {
//               if (isDef(i.create)) { i.create(emptyNode, vnode) }
//               if (isDef(i.insert)) { insertedVnodeQueue.push(vnode) }
//             }
//           }

//           // set scope id attribute for scoped CSS.
//           // this is implemented as a special case to avoid the overhead
//           // of going through the normal attribute patching process.
//           function setScope (vnode) {
//             var i
//             if (isDef(i = vnode.fnScopeId)) {
//               nodeOps.setAttribute(vnode.elm, i, '')
//             } else {
//               var ancestor = vnode
//               while (ancestor) {
//                 if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
//                   nodeOps.setAttribute(vnode.elm, i, '')
//                 }
//                 ancestor = ancestor.parent
//               }
//             }
//             // for slot content they should also get the scopeId from the host instance.
//             if (isDef(i = activeInstance) &&
//       i !== vnode.context &&
//       i !== vnode.fnContext &&
//       isDef(i = i.$options._scopeId)
//             ) {
//               nodeOps.setAttribute(vnode.elm, i, '')
//             }
//           }

//           function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
//             for (; startIdx <= endIdx; ++startIdx) {
//               createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm)
//             }
//           }

//           function invokeDestroyHook (vnode) {
//             var i, j
//             var data = vnode.data
//             if (isDef(data)) {
//               if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode) }
//               for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode) }
//             }
//             if (isDef(i = vnode.children)) {
//               for (j = 0; j < vnode.children.length; ++j) {
//                 invokeDestroyHook(vnode.children[j])
//               }
//             }
//           }

//           function removeVnodes (parentElm, vnodes, startIdx, endIdx) {
//             for (; startIdx <= endIdx; ++startIdx) {
//               var ch = vnodes[startIdx]
//               if (isDef(ch)) {
//                 if (isDef(ch.tag)) {
//                   removeAndInvokeRemoveHook(ch)
//                   invokeDestroyHook(ch)
//                 } else { // Text node
//                   removeNode(ch.elm)
//                 }
//               }
//             }
//           }

//           function removeAndInvokeRemoveHook (vnode, rm) {
//             if (isDef(rm) || isDef(vnode.data)) {
//               var i
//               var listeners = cbs.remove.length + 1
//               if (isDef(rm)) {
//                 // we have a recursively passed down rm callback
//                 // increase the listeners count
//                 rm.listeners += listeners
//               } else {
//                 // directly removing
//                 rm = createRmCb(vnode.elm, listeners)
//               }
//               // recursively invoke hooks on child component root node
//               if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
//                 removeAndInvokeRemoveHook(i, rm)
//               }
//               for (i = 0; i < cbs.remove.length; ++i) {
//                 cbs.remove[i](vnode, rm)
//               }
//               if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
//                 i(vnode, rm)
//               } else {
//                 rm()
//               }
//             } else {
//               removeNode(vnode.elm)
//             }
//           }

//           function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
//             var oldStartIdx = 0
//             var newStartIdx = 0
//             var oldEndIdx = oldCh.length - 1
//             var oldStartVnode = oldCh[0]
//             var oldEndVnode = oldCh[oldEndIdx]
//             var newEndIdx = newCh.length - 1
//             var newStartVnode = newCh[0]
//             var newEndVnode = newCh[newEndIdx]
//             var oldKeyToIdx, idxInOld, vnodeToMove, refElm

//             // removeOnly is a special flag used only by <transition-group>
//             // to ensure removed elements stay in correct relative positions
//             // during leaving transitions
//             var canMove = !removeOnly

//             if (true) {
//               checkDuplicateKeys(newCh)
//             }

//             while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
//               if (isUndef(oldStartVnode)) {
//                 oldStartVnode = oldCh[++oldStartIdx] // Vnode has been moved left
//               } else if (isUndef(oldEndVnode)) {
//                 oldEndVnode = oldCh[--oldEndIdx]
//               } else if (sameVnode(oldStartVnode, newStartVnode)) {
//                 patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue)
//                 oldStartVnode = oldCh[++oldStartIdx]
//                 newStartVnode = newCh[++newStartIdx]
//               } else if (sameVnode(oldEndVnode, newEndVnode)) {
//                 patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue)
//                 oldEndVnode = oldCh[--oldEndIdx]
//                 newEndVnode = newCh[--newEndIdx]
//               } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
//                 patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue)
//                 canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm))
//                 oldStartVnode = oldCh[++oldStartIdx]
//                 newEndVnode = newCh[--newEndIdx]
//               } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
//                 patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue)
//                 canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
//                 oldEndVnode = oldCh[--oldEndIdx]
//                 newStartVnode = newCh[++newStartIdx]
//               } else {
//                 if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx) }
//                 idxInOld = isDef(newStartVnode.key)
//                   ? oldKeyToIdx[newStartVnode.key]
//                   : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx)
//                 if (isUndef(idxInOld)) { // New element
//                   createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm)
//                 } else {
//                   vnodeToMove = oldCh[idxInOld]
//                   if (sameVnode(vnodeToMove, newStartVnode)) {
//                     patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue)
//                     oldCh[idxInOld] = undefined
//                     canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm)
//                   } else {
//                     // same key but different element. treat as new element
//                     createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm)
//                   }
//                 }
//                 newStartVnode = newCh[++newStartIdx]
//               }
//             }
//             if (oldStartIdx > oldEndIdx) {
//               refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm
//               addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue)
//             } else if (newStartIdx > newEndIdx) {
//               removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx)
//             }
//           }

//           function checkDuplicateKeys (children) {
//             var seenKeys = {}
//             for (var i = 0; i < children.length; i++) {
//               var vnode = children[i]
//               var key = vnode.key
//               if (isDef(key)) {
//                 if (seenKeys[key]) {
//                   warn(
//                     ('Duplicate keys detected: \'' + key + '\'. This may cause an update error.'),
//                     vnode.context
//                   )
//                 } else {
//                   seenKeys[key] = true
//                 }
//               }
//             }
//           }

//           function findIdxInOld (node, oldCh, start, end) {
//             for (var i = start; i < end; i++) {
//               var c = oldCh[i]
//               if (isDef(c) && sameVnode(node, c)) { return i }
//             }
//           }

//           function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {
//             if (oldVnode === vnode) {
//               return
//             }

//             var elm = vnode.elm = oldVnode.elm

//             if (isTrue(oldVnode.isAsyncPlaceholder)) {
//               if (isDef(vnode.asyncFactory.resolved)) {
//                 hydrate(oldVnode.elm, vnode, insertedVnodeQueue)
//               } else {
//                 vnode.isAsyncPlaceholder = true
//               }
//               return
//             }

//             // reuse element for static trees.
//             // note we only do this if the vnode is cloned -
//             // if the new node is not cloned it means the render functions have been
//             // reset by the hot-reload-api and we need to do a proper re-render.
//             if (isTrue(vnode.isStatic) &&
//       isTrue(oldVnode.isStatic) &&
//       vnode.key === oldVnode.key &&
//       (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
//             ) {
//               vnode.componentInstance = oldVnode.componentInstance
//               return
//             }

//             var i
//             var data = vnode.data
//             if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
//               i(oldVnode, vnode)
//             }

//             var oldCh = oldVnode.children
//             var ch = vnode.children
//             if (isDef(data) && isPatchable(vnode)) {
//               for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode) }
//               if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode) }
//             }
//             if (isUndef(vnode.text)) {
//               if (isDef(oldCh) && isDef(ch)) {
//                 if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly) }
//               } else if (isDef(ch)) {
//                 if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, '') }
//                 addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue)
//               } else if (isDef(oldCh)) {
//                 removeVnodes(elm, oldCh, 0, oldCh.length - 1)
//               } else if (isDef(oldVnode.text)) {
//                 nodeOps.setTextContent(elm, '')
//               }
//             } else if (oldVnode.text !== vnode.text) {
//               nodeOps.setTextContent(elm, vnode.text)
//             }
//             if (isDef(data)) {
//               if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode) }
//             }
//           }

//           function invokeInsertHook (vnode, queue, initial) {
//             // delay insert hooks for component root nodes, invoke them after the
//             // element is really inserted
//             if (isTrue(initial) && isDef(vnode.parent)) {
//               vnode.parent.data.pendingInsert = queue
//             } else {
//               for (var i = 0; i < queue.length; ++i) {
//                 queue[i].data.hook.insert(queue[i])
//               }
//             }
//           }

//           var hydrationBailed = false
//           // list of modules that can skip create hook during hydration because they
//           // are already rendered on the client or has no need for initialization
//           // Note: style is excluded because it relies on initial clone for future
//           // deep updates (#7063).
//           var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key')

//           // Note: this is a browser-only function so we can assume elms are DOM nodes.
//           function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
//             var i
//             var tag = vnode.tag
//             var data = vnode.data
//             var children = vnode.children
//             inVPre = inVPre || (data && data.pre)
//             vnode.elm = elm

//             if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
//               vnode.isAsyncPlaceholder = true
//               return true
//             }
//             // assert node match
//             if (true) {
//               if (!assertNodeMatch(elm, vnode, inVPre)) {
//                 return false
//               }
//             }
//             if (isDef(data)) {
//               if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */) }
//               if (isDef(i = vnode.componentInstance)) {
//                 // child component. it should have hydrated its own tree.
//                 initComponent(vnode, insertedVnodeQueue)
//                 return true
//               }
//             }
//             if (isDef(tag)) {
//               if (isDef(children)) {
//                 // empty element, allow client to pick up and populate children
//                 if (!elm.hasChildNodes()) {
//                   createChildren(vnode, children, insertedVnodeQueue)
//                 } else {
//                   // v-html and domProps: innerHTML
//                   if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
//                     if (i !== elm.innerHTML) {
//                       /* istanbul ignore if */
//                       if (true &&
//                 typeof console !== 'undefined' &&
//                 !hydrationBailed
//                       ) {
//                         hydrationBailed = true
//                         console.warn('Parent: ', elm)
//                         console.warn('server innerHTML: ', i)
//                         console.warn('client innerHTML: ', elm.innerHTML)
//                       }
//                       return false
//                     }
//                   } else {
//                     // iterate and compare children lists
//                     var childrenMatch = true
//                     var childNode = elm.firstChild
//                     for (var i$1 = 0; i$1 < children.length; i$1++) {
//                       if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
//                         childrenMatch = false
//                         break
//                       }
//                       childNode = childNode.nextSibling
//                     }
//                     // if childNode is not null, it means the actual childNodes list is
//                     // longer than the virtual children list.
//                     if (!childrenMatch || childNode) {
//                       /* istanbul ignore if */
//                       if (true &&
//                 typeof console !== 'undefined' &&
//                 !hydrationBailed
//                       ) {
//                         hydrationBailed = true
//                         console.warn('Parent: ', elm)
//                         console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children)
//                       }
//                       return false
//                     }
//                   }
//                 }
//               }
//               if (isDef(data)) {
//                 var fullInvoke = false
//                 for (var key in data) {
//                   if (!isRenderedModule(key)) {
//                     fullInvoke = true
//                     invokeCreateHooks(vnode, insertedVnodeQueue)
//                     break
//                   }
//                 }
//                 if (!fullInvoke && data['class']) {
//                   // ensure collecting deps for deep class bindings for future updates
//                   traverse(data['class'])
//                 }
//               }
//             } else if (elm.data !== vnode.text) {
//               elm.data = vnode.text
//             }
//             return true
//           }

//           function assertNodeMatch (node, vnode, inVPre) {
//             if (isDef(vnode.tag)) {
//               return vnode.tag.indexOf('vue-component') === 0 || (
//                 !isUnknownElement$$1(vnode, inVPre) &&
//         vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
//               )
//             } else {
//               return node.nodeType === (vnode.isComment ? 8 : 3)
//             }
//           }

//           return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {
//             if (isUndef(vnode)) {
//               if (isDef(oldVnode)) { invokeDestroyHook(oldVnode) }
//               return
//             }

//             var isInitialPatch = false
//             var insertedVnodeQueue = []

//             if (isUndef(oldVnode)) {
//               // empty mount (likely as component), create new root element
//               isInitialPatch = true
//               createElm(vnode, insertedVnodeQueue, parentElm, refElm)
//             } else {
//               var isRealElement = isDef(oldVnode.nodeType)
//               if (!isRealElement && sameVnode(oldVnode, vnode)) {
//                 // patch existing root node
//                 patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly)
//               } else {
//                 if (isRealElement) {
//                   // mounting to a real element
//                   // check if this is server-rendered content and if we can perform
//                   // a successful hydration.
//                   if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
//                     oldVnode.removeAttribute(SSR_ATTR)
//                     hydrating = true
//                   }
//                   if (isTrue(hydrating)) {
//                     if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
//                       invokeInsertHook(vnode, insertedVnodeQueue, true)
//                       return oldVnode
//                     } else if (true) {
//                       warn(
//                         'The client-side rendered virtual DOM tree is not matching ' +
//                 'server-rendered content. This is likely caused by incorrect ' +
//                 'HTML markup, for example nesting block-level elements inside ' +
//                 '<p>, or missing <tbody>. Bailing hydration and performing ' +
//                 'full client-side render.'
//                       )
//                     }
//                   }
//                   // either not server-rendered, or hydration failed.
//                   // create an empty node and replace it
//                   oldVnode = emptyNodeAt(oldVnode)
//                 }

//                 // replacing existing element
//                 var oldElm = oldVnode.elm
//                 var parentElm$1 = nodeOps.parentNode(oldElm)

//                 // create new node
//                 createElm(
//                   vnode,
//                   insertedVnodeQueue,
//                   // extremely rare edge case: do not insert if old element is in a
//                   // leaving transition. Only happens when combining transition +
//                   // keep-alive + HOCs. (#4590)
//                   oldElm._leaveCb ? null : parentElm$1,
//                   nodeOps.nextSibling(oldElm)
//                 )

//                 // update parent placeholder node element, recursively
//                 if (isDef(vnode.parent)) {
//                   var ancestor = vnode.parent
//                   var patchable = isPatchable(vnode)
//                   while (ancestor) {
//                     for (var i = 0; i < cbs.destroy.length; ++i) {
//                       cbs.destroy[i](ancestor)
//                     }
//                     ancestor.elm = vnode.elm
//                     if (patchable) {
//                       for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
//                         cbs.create[i$1](emptyNode, ancestor)
//                       }
//                       // #6513
//                       // invoke insert hooks that may have been merged by create hooks.
//                       // e.g. for directives that uses the "inserted" hook.
//                       var insert = ancestor.data.hook.insert
//                       if (insert.merged) {
//                         // start at index 1 to avoid re-invoking component mounted hook
//                         for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
//                           insert.fns[i$2]()
//                         }
//                       }
//                     } else {
//                       registerRef(ancestor)
//                     }
//                     ancestor = ancestor.parent
//                   }
//                 }

//                 // destroy old node
//                 if (isDef(parentElm$1)) {
//                   removeVnodes(parentElm$1, [oldVnode], 0, 0)
//                 } else if (isDef(oldVnode.tag)) {
//                   invokeDestroyHook(oldVnode)
//                 }
//               }
//             }

//             invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch)
//             return vnode.elm
//           }
//         }

//         /*  */

//         var directives = {
//           create: updateDirectives,
//           update: updateDirectives,
//           destroy: function unbindDirectives (vnode) {
//             updateDirectives(vnode, emptyNode)
//           }
//         }

//         function updateDirectives (oldVnode, vnode) {
//           if (oldVnode.data.directives || vnode.data.directives) {
//             _update(oldVnode, vnode)
//           }
//         }

//         function _update (oldVnode, vnode) {
//           var isCreate = oldVnode === emptyNode
//           var isDestroy = vnode === emptyNode
//           var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context)
//           var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context)

//           var dirsWithInsert = []
//           var dirsWithPostpatch = []

//           var key, oldDir, dir
//           for (key in newDirs) {
//             oldDir = oldDirs[key]
//             dir = newDirs[key]
//             if (!oldDir) {
//               // new directive, bind
//               callHook$1(dir, 'bind', vnode, oldVnode)
//               if (dir.def && dir.def.inserted) {
//                 dirsWithInsert.push(dir)
//               }
//             } else {
//               // existing directive, update
//               dir.oldValue = oldDir.value
//               callHook$1(dir, 'update', vnode, oldVnode)
//               if (dir.def && dir.def.componentUpdated) {
//                 dirsWithPostpatch.push(dir)
//               }
//             }
//           }

//           if (dirsWithInsert.length) {
//             var callInsert = function () {
//               for (var i = 0; i < dirsWithInsert.length; i++) {
//                 callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode)
//               }
//             }
//             if (isCreate) {
//               mergeVNodeHook(vnode, 'insert', callInsert)
//             } else {
//               callInsert()
//             }
//           }

//           if (dirsWithPostpatch.length) {
//             mergeVNodeHook(vnode, 'postpatch', function () {
//               for (var i = 0; i < dirsWithPostpatch.length; i++) {
//                 callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode)
//               }
//             })
//           }

//           if (!isCreate) {
//             for (key in oldDirs) {
//               if (!newDirs[key]) {
//                 // no longer present, unbind
//                 callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy)
//               }
//             }
//           }
//         }

//         var emptyModifiers = Object.create(null)

//         function normalizeDirectives$1 (
//           dirs,
//           vm
//         ) {
//           var res = Object.create(null)
//           if (!dirs) {
//             // $flow-disable-line
//             return res
//           }
//           var i, dir
//           for (i = 0; i < dirs.length; i++) {
//             dir = dirs[i]
//             if (!dir.modifiers) {
//               // $flow-disable-line
//               dir.modifiers = emptyModifiers
//             }
//             res[getRawDirName(dir)] = dir
//             dir.def = resolveAsset(vm.$options, 'directives', dir.name, true)
//           }
//           // $flow-disable-line
//           return res
//         }

//         function getRawDirName (dir) {
//           return dir.rawName || ((dir.name) + '.' + (Object.keys(dir.modifiers || {}).join('.')))
//         }

//         function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
//           var fn = dir.def && dir.def[hook]
//           if (fn) {
//             try {
//               fn(vnode.elm, dir, vnode, oldVnode, isDestroy)
//             } catch (e) {
//               handleError(e, vnode.context, ('directive ' + (dir.name) + ' ' + hook + ' hook'))
//             }
//           }
//         }

//         var baseModules = [
//           ref,
//           directives
//         ]

//         /*  */

//         function updateAttrs (oldVnode, vnode) {
//           var opts = vnode.componentOptions
//           if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
//             return
//           }
//           if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
//             return
//           }
//           var key, cur, old
//           var elm = vnode.elm
//           var oldAttrs = oldVnode.data.attrs || {}
//           var attrs = vnode.data.attrs || {}
//           // clone observed objects, as the user probably wants to mutate it
//           if (isDef(attrs.__ob__)) {
//             attrs = vnode.data.attrs = extend({}, attrs)
//           }

//           for (key in attrs) {
//             cur = attrs[key]
//             old = oldAttrs[key]
//             if (old !== cur) {
//               setAttr(elm, key, cur)
//             }
//           }
//           // #4391: in IE9, setting type can reset value for input[type=radio]
//           // #6666: IE/Edge forces progress value down to 1 before setting a max
//           /* istanbul ignore if */
//           if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
//             setAttr(elm, 'value', attrs.value)
//           }
//           for (key in oldAttrs) {
//             if (isUndef(attrs[key])) {
//               if (isXlink(key)) {
//                 elm.removeAttributeNS(xlinkNS, getXlinkProp(key))
//               } else if (!isEnumeratedAttr(key)) {
//                 elm.removeAttribute(key)
//               }
//             }
//           }
//         }

//         function setAttr (el, key, value) {
//           if (isBooleanAttr(key)) {
//             // set attribute for blank value
//             // e.g. <option disabled>Select one</option>
//             if (isFalsyAttrValue(value)) {
//               el.removeAttribute(key)
//             } else {
//               // technically allowfullscreen is a boolean attribute for <iframe>,
//               // but Flash expects a value of "true" when used on <embed> tag
//               value = key === 'allowfullscreen' && el.tagName === 'EMBED'
//                 ? 'true'
//                 : key
//               el.setAttribute(key, value)
//             }
//           } else if (isEnumeratedAttr(key)) {
//             el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true')
//           } else if (isXlink(key)) {
//             if (isFalsyAttrValue(value)) {
//               el.removeAttributeNS(xlinkNS, getXlinkProp(key))
//             } else {
//               el.setAttributeNS(xlinkNS, key, value)
//             }
//           } else {
//             if (isFalsyAttrValue(value)) {
//               el.removeAttribute(key)
//             } else {
//               // #7138: IE10 & 11 fires input event when setting placeholder on
//               // <textarea>... block the first input event and remove the blocker
//               // immediately.
//               /* istanbul ignore if */
//               if (
//                 isIE && !isIE9 &&
//         el.tagName === 'TEXTAREA' &&
//         key === 'placeholder' && !el.__ieph
//               ) {
//                 var blocker = function (e) {
//                   e.stopImmediatePropagation()
//                   el.removeEventListener('input', blocker)
//                 }
//                 el.addEventListener('input', blocker)
//                 // $flow-disable-line
//                 el.__ieph = true /* IE placeholder patched */
//               }
//               el.setAttribute(key, value)
//             }
//           }
//         }

//         var attrs = {
//           create: updateAttrs,
//           update: updateAttrs
//         }

//         /*  */

//         function updateClass (oldVnode, vnode) {
//           var el = vnode.elm
//           var data = vnode.data
//           var oldData = oldVnode.data
//           if (
//             isUndef(data.staticClass) &&
//     isUndef(data.class) && (
//               isUndef(oldData) || (
//                 isUndef(oldData.staticClass) &&
//         isUndef(oldData.class)
//               )
//             )
//           ) {
//             return
//           }

//           var cls = genClassForVnode(vnode)

//           // handle transition classes
//           var transitionClass = el._transitionClasses
//           if (isDef(transitionClass)) {
//             cls = concat(cls, stringifyClass(transitionClass))
//           }

//           // set the class
//           if (cls !== el._prevClass) {
//             el.setAttribute('class', cls)
//             el._prevClass = cls
//           }
//         }

//         var klass = {
//           create: updateClass,
//           update: updateClass
//         }

//         /*  */

//         /*  */

//         // add a raw attr (use this in preTransforms)

//         // note: this only removes the attr from the Array (attrsList) so that it
//         // doesn't get processed by processAttrs.
//         // By default it does NOT remove it from the map (attrsMap) because the map is
//         // needed during codegen.

//         /*  */

//         /**
//  * Cross-platform code generation for component v-model
//  */

//         /**
//  * Cross-platform codegen helper for generating v-model value assignment code.
//  */

//         /*  */

//         // in some cases, the event used has to be determined at runtime
//         // so we used some reserved tokens during compile.
//         var RANGE_TOKEN = '__r'
//         var CHECKBOX_RADIO_TOKEN = '__c'

//         /*  */

//         // normalize v-model event tokens that can only be determined at runtime.
//         // it's important to place the event as the first in the array because
//         // the whole point is ensuring the v-model callback gets called before
//         // user-attached handlers.
//         function normalizeEvents (on) {
//           /* istanbul ignore if */
//           if (isDef(on[RANGE_TOKEN])) {
//             // IE input[type=range] only supports `change` event
//             var event = isIE ? 'change' : 'input'
//             on[event] = [].concat(on[RANGE_TOKEN], on[event] || [])
//             delete on[RANGE_TOKEN]
//           }
//           // This was originally intended to fix #4521 but no longer necessary
//           // after 2.5. Keeping it for backwards compat with generated code from < 2.4
//           /* istanbul ignore if */
//           if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
//             on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || [])
//             delete on[CHECKBOX_RADIO_TOKEN]
//           }
//         }

//         var target$1

//         function createOnceHandler (handler, event, capture) {
//           var _target = target$1 // save current target element in closure
//           return function onceHandler () {
//             var res = handler.apply(null, arguments)
//             if (res !== null) {
//               remove$2(event, onceHandler, capture, _target)
//             }
//           }
//         }

//         function add$1 (
//           event,
//           handler,
//           once$$1,
//           capture,
//           passive
//         ) {
//           handler = withMacroTask(handler)
//           if (once$$1) { handler = createOnceHandler(handler, event, capture) }
//           target$1.addEventListener(
//             event,
//             handler,
//             supportsPassive
//               ? { capture: capture, passive: passive }
//               : capture
//           )
//         }

//         function remove$2 (
//           event,
//           handler,
//           capture,
//           _target
//         ) {
//           (_target || target$1).removeEventListener(
//             event,
//             handler._withTask || handler,
//             capture
//           )
//         }

//         function updateDOMListeners (oldVnode, vnode) {
//           if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
//             return
//           }
//           var on = vnode.data.on || {}
//           var oldOn = oldVnode.data.on || {}
//           target$1 = vnode.elm
//           normalizeEvents(on)
//           updateListeners(on, oldOn, add$1, remove$2, vnode.context)
//           target$1 = undefined
//         }

//         var events = {
//           create: updateDOMListeners,
//           update: updateDOMListeners
//         }

//         /*  */

//         function updateDOMProps (oldVnode, vnode) {
//           if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
//             return
//           }
//           var key, cur
//           var elm = vnode.elm
//           var oldProps = oldVnode.data.domProps || {}
//           var props = vnode.data.domProps || {}
//           // clone observed objects, as the user probably wants to mutate it
//           if (isDef(props.__ob__)) {
//             props = vnode.data.domProps = extend({}, props)
//           }

//           for (key in oldProps) {
//             if (isUndef(props[key])) {
//               elm[key] = ''
//             }
//           }
//           for (key in props) {
//             cur = props[key]
//             // ignore children if the node has textContent or innerHTML,
//             // as these will throw away existing DOM nodes and cause removal errors
//             // on subsequent patches (#3360)
//             if (key === 'textContent' || key === 'innerHTML') {
//               if (vnode.children) { vnode.children.length = 0 }
//               if (cur === oldProps[key]) { continue }
//               // #6601 work around Chrome version <= 55 bug where single textNode
//               // replaced by innerHTML/textContent retains its parentNode property
//               if (elm.childNodes.length === 1) {
//                 elm.removeChild(elm.childNodes[0])
//               }
//             }

//             if (key === 'value') {
//               // store value as _value as well since
//               // non-string values will be stringified
//               elm._value = cur
//               // avoid resetting cursor position when value is the same
//               var strCur = isUndef(cur) ? '' : String(cur)
//               if (shouldUpdateValue(elm, strCur)) {
//                 elm.value = strCur
//               }
//             } else {
//               elm[key] = cur
//             }
//           }
//         }

//         // check platforms/web/util/attrs.js acceptValue

//         function shouldUpdateValue (elm, checkVal) {
//           return (!elm.composing && (
//             elm.tagName === 'OPTION' ||
//     isNotInFocusAndDirty(elm, checkVal) ||
//     isDirtyWithModifiers(elm, checkVal)
//           ))
//         }

//         function isNotInFocusAndDirty (elm, checkVal) {
//           // return true when textbox (.number and .trim) loses focus and its value is
//           // not equal to the updated value
//           var notInFocus = true
//           // #6157
//           // work around IE bug when accessing document.activeElement in an iframe
//           try { notInFocus = document.activeElement !== elm } catch (e) {}
//           return notInFocus && elm.value !== checkVal
//         }

//         function isDirtyWithModifiers (elm, newVal) {
//           var value = elm.value
//           var modifiers = elm._vModifiers // injected by v-model runtime
//           if (isDef(modifiers)) {
//             if (modifiers.lazy) {
//               // inputs with lazy should only be updated when not in focus
//               return false
//             }
//             if (modifiers.number) {
//               return toNumber(value) !== toNumber(newVal)
//             }
//             if (modifiers.trim) {
//               return value.trim() !== newVal.trim()
//             }
//           }
//           return value !== newVal
//         }

//         var domProps = {
//           create: updateDOMProps,
//           update: updateDOMProps
//         }

//         /*  */

//         var parseStyleText = cached(function (cssText) {
//           var res = {}
//           var listDelimiter = /;(?![^(]*\))/g
//           var propertyDelimiter = /:(.+)/
//           cssText.split(listDelimiter).forEach(function (item) {
//             if (item) {
//               var tmp = item.split(propertyDelimiter)
//               tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim())
//             }
//           })
//           return res
//         })

//         // merge static and dynamic style data on the same vnode
//         function normalizeStyleData (data) {
//           var style = normalizeStyleBinding(data.style)
//           // static style is pre-processed into an object during compilation
//           // and is always a fresh object, so it's safe to merge into it
//           return data.staticStyle
//             ? extend(data.staticStyle, style)
//             : style
//         }

//         // normalize possible array / string values into Object
//         function normalizeStyleBinding (bindingStyle) {
//           if (Array.isArray(bindingStyle)) {
//             return toObject(bindingStyle)
//           }
//           if (typeof bindingStyle === 'string') {
//             return parseStyleText(bindingStyle)
//           }
//           return bindingStyle
//         }

//         /**
//  * parent component style should be after child's
//  * so that parent component's style could override it
//  */
//         function getStyle (vnode, checkChild) {
//           var res = {}
//           var styleData

//           if (checkChild) {
//             var childNode = vnode
//             while (childNode.componentInstance) {
//               childNode = childNode.componentInstance._vnode
//               if (
//                 childNode && childNode.data &&
//         (styleData = normalizeStyleData(childNode.data))
//               ) {
//                 extend(res, styleData)
//               }
//             }
//           }

//           if ((styleData = normalizeStyleData(vnode.data))) {
//             extend(res, styleData)
//           }

//           var parentNode = vnode
//           while ((parentNode = parentNode.parent)) {
//             if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
//               extend(res, styleData)
//             }
//           }
//           return res
//         }

//         /*  */

//         var cssVarRE = /^--/
//         var importantRE = /\s*!important$/
//         var setProp = function (el, name, val) {
//           /* istanbul ignore if */
//           if (cssVarRE.test(name)) {
//             el.style.setProperty(name, val)
//           } else if (importantRE.test(val)) {
//             el.style.setProperty(name, val.replace(importantRE, ''), 'important')
//           } else {
//             var normalizedName = normalize(name)
//             if (Array.isArray(val)) {
//               // Support values array created by autoprefixer, e.g.
//               // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
//               // Set them one by one, and the browser will only set those it can recognize
//               for (var i = 0, len = val.length; i < len; i++) {
//                 el.style[normalizedName] = val[i]
//               }
//             } else {
//               el.style[normalizedName] = val
//             }
//           }
//         }

//         var vendorNames = ['Webkit', 'Moz', 'ms']

//         var emptyStyle
//         var normalize = cached(function (prop) {
//           emptyStyle = emptyStyle || document.createElement('div').style
//           prop = camelize(prop)
//           if (prop !== 'filter' && (prop in emptyStyle)) {
//             return prop
//           }
//           var capName = prop.charAt(0).toUpperCase() + prop.slice(1)
//           for (var i = 0; i < vendorNames.length; i++) {
//             var name = vendorNames[i] + capName
//             if (name in emptyStyle) {
//               return name
//             }
//           }
//         })

//         function updateStyle (oldVnode, vnode) {
//           var data = vnode.data
//           var oldData = oldVnode.data

//           if (isUndef(data.staticStyle) && isUndef(data.style) &&
//     isUndef(oldData.staticStyle) && isUndef(oldData.style)
//           ) {
//             return
//           }

//           var cur, name
//           var el = vnode.elm
//           var oldStaticStyle = oldData.staticStyle
//           var oldStyleBinding = oldData.normalizedStyle || oldData.style || {}

//           // if static style exists, stylebinding already merged into it when doing normalizeStyleData
//           var oldStyle = oldStaticStyle || oldStyleBinding

//           var style = normalizeStyleBinding(vnode.data.style) || {}

//           // store normalized style under a different key for next diff
//           // make sure to clone it if it's reactive, since the user likely wants
//           // to mutate it.
//           vnode.data.normalizedStyle = isDef(style.__ob__)
//             ? extend({}, style)
//             : style

//           var newStyle = getStyle(vnode, true)

//           for (name in oldStyle) {
//             if (isUndef(newStyle[name])) {
//               setProp(el, name, '')
//             }
//           }
//           for (name in newStyle) {
//             cur = newStyle[name]
//             if (cur !== oldStyle[name]) {
//               // ie9 setting to null has no effect, must use empty string
//               setProp(el, name, cur == null ? '' : cur)
//             }
//           }
//         }

//         var style = {
//           create: updateStyle,
//           update: updateStyle
//         }

//         /*  */

//         /**
//  * Add class with compatibility for SVG since classList is not supported on
//  * SVG elements in IE
//  */
//         function addClass (el, cls) {
//           /* istanbul ignore if */
//           if (!cls || !(cls = cls.trim())) {
//             return
//           }

//           /* istanbul ignore else */
//           if (el.classList) {
//             if (cls.indexOf(' ') > -1) {
//               cls.split(/\s+/).forEach(function (c) { return el.classList.add(c) })
//             } else {
//               el.classList.add(cls)
//             }
//           } else {
//             var cur = ' ' + (el.getAttribute('class') || '') + ' '
//             if (cur.indexOf(' ' + cls + ' ') < 0) {
//               el.setAttribute('class', (cur + cls).trim())
//             }
//           }
//         }

//         /**
//  * Remove class with compatibility for SVG since classList is not supported on
//  * SVG elements in IE
//  */
//         function removeClass (el, cls) {
//           /* istanbul ignore if */
//           if (!cls || !(cls = cls.trim())) {
//             return
//           }

//           /* istanbul ignore else */
//           if (el.classList) {
//             if (cls.indexOf(' ') > -1) {
//               cls.split(/\s+/).forEach(function (c) { return el.classList.remove(c) })
//             } else {
//               el.classList.remove(cls)
//             }
//             if (!el.classList.length) {
//               el.removeAttribute('class')
//             }
//           } else {
//             var cur = ' ' + (el.getAttribute('class') || '') + ' '
//             var tar = ' ' + cls + ' '
//             while (cur.indexOf(tar) >= 0) {
//               cur = cur.replace(tar, ' ')
//             }
//             cur = cur.trim()
//             if (cur) {
//               el.setAttribute('class', cur)
//             } else {
//               el.removeAttribute('class')
//             }
//           }
//         }

//         /*  */

//         function resolveTransition (def) {
//           if (!def) {
//             return
//           }
//           /* istanbul ignore else */
//           if (typeof def === 'object') {
//             var res = {}
//             if (def.css !== false) {
//               extend(res, autoCssTransition(def.name || 'v'))
//             }
//             extend(res, def)
//             return res
//           } else if (typeof def === 'string') {
//             return autoCssTransition(def)
//           }
//         }

//         var autoCssTransition = cached(function (name) {
//           return {
//             enterClass: (name + '-enter'),
//             enterToClass: (name + '-enter-to'),
//             enterActiveClass: (name + '-enter-active'),
//             leaveClass: (name + '-leave'),
//             leaveToClass: (name + '-leave-to'),
//             leaveActiveClass: (name + '-leave-active')
//           }
//         })

//         var hasTransition = inBrowser && !isIE9
//         var TRANSITION = 'transition'
//         var ANIMATION = 'animation'

//         // Transition property/event sniffing
//         var transitionProp = 'transition'
//         var transitionEndEvent = 'transitionend'
//         var animationProp = 'animation'
//         var animationEndEvent = 'animationend'
//         if (hasTransition) {
//           /* istanbul ignore if */
//           if (window.ontransitionend === undefined &&
//     window.onwebkittransitionend !== undefined
//           ) {
//             transitionProp = 'WebkitTransition'
//             transitionEndEvent = 'webkitTransitionEnd'
//           }
//           if (window.onanimationend === undefined &&
//     window.onwebkitanimationend !== undefined
//           ) {
//             animationProp = 'WebkitAnimation'
//             animationEndEvent = 'webkitAnimationEnd'
//           }
//         }

//         // binding to window is necessary to make hot reload work in IE in strict mode
//         var raf = inBrowser
//           ? window.requestAnimationFrame
//             ? window.requestAnimationFrame.bind(window)
//             : setTimeout
//           : /* istanbul ignore next */ function (fn) { return fn() }

//         function nextFrame (fn) {
//           raf(function () {
//             raf(fn)
//           })
//         }

//         function addTransitionClass (el, cls) {
//           var transitionClasses = el._transitionClasses || (el._transitionClasses = [])
//           if (transitionClasses.indexOf(cls) < 0) {
//             transitionClasses.push(cls)
//             addClass(el, cls)
//           }
//         }

//         function removeTransitionClass (el, cls) {
//           if (el._transitionClasses) {
//             remove(el._transitionClasses, cls)
//           }
//           removeClass(el, cls)
//         }

//         function whenTransitionEnds (
//           el,
//           expectedType,
//           cb
//         ) {
//           var ref = getTransitionInfo(el, expectedType)
//           var type = ref.type
//           var timeout = ref.timeout
//           var propCount = ref.propCount
//           if (!type) { return cb() }
//           var event = type === TRANSITION ? transitionEndEvent : animationEndEvent
//           var ended = 0
//           var end = function () {
//             el.removeEventListener(event, onEnd)
//             cb()
//           }
//           var onEnd = function (e) {
//             if (e.target === el) {
//               if (++ended >= propCount) {
//                 end()
//               }
//             }
//           }
//           setTimeout(function () {
//             if (ended < propCount) {
//               end()
//             }
//           }, timeout + 1)
//           el.addEventListener(event, onEnd)
//         }

//         var transformRE = /\b(transform|all)(,|$)/

//         function getTransitionInfo (el, expectedType) {
//           var styles = window.getComputedStyle(el)
//           var transitionDelays = styles[transitionProp + 'Delay'].split(', ')
//           var transitionDurations = styles[transitionProp + 'Duration'].split(', ')
//           var transitionTimeout = getTimeout(transitionDelays, transitionDurations)
//           var animationDelays = styles[animationProp + 'Delay'].split(', ')
//           var animationDurations = styles[animationProp + 'Duration'].split(', ')
//           var animationTimeout = getTimeout(animationDelays, animationDurations)

//           var type
//           var timeout = 0
//           var propCount = 0
//           /* istanbul ignore if */
//           if (expectedType === TRANSITION) {
//             if (transitionTimeout > 0) {
//               type = TRANSITION
//               timeout = transitionTimeout
//               propCount = transitionDurations.length
//             }
//           } else if (expectedType === ANIMATION) {
//             if (animationTimeout > 0) {
//               type = ANIMATION
//               timeout = animationTimeout
//               propCount = animationDurations.length
//             }
//           } else {
//             timeout = Math.max(transitionTimeout, animationTimeout)
//             type = timeout > 0
//               ? transitionTimeout > animationTimeout
//                 ? TRANSITION
//                 : ANIMATION
//               : null
//             propCount = type
//               ? type === TRANSITION
//                 ? transitionDurations.length
//                 : animationDurations.length
//               : 0
//           }
//           var hasTransform =
//     type === TRANSITION &&
//     transformRE.test(styles[transitionProp + 'Property'])
//           return {
//             type: type,
//             timeout: timeout,
//             propCount: propCount,
//             hasTransform: hasTransform
//           }
//         }

//         function getTimeout (delays, durations) {
//           /* istanbul ignore next */
//           while (delays.length < durations.length) {
//             delays = delays.concat(delays)
//           }

//           return Math.max.apply(null, durations.map(function (d, i) {
//             return toMs(d) + toMs(delays[i])
//           }))
//         }

//         function toMs (s) {
//           return Number(s.slice(0, -1)) * 1000
//         }

//         /*  */

//         function enter (vnode, toggleDisplay) {
//           var el = vnode.elm

//           // call leave callback now
//           if (isDef(el._leaveCb)) {
//             el._leaveCb.cancelled = true
//             el._leaveCb()
//           }

//           var data = resolveTransition(vnode.data.transition)
//           if (isUndef(data)) {
//             return
//           }

//           /* istanbul ignore if */
//           if (isDef(el._enterCb) || el.nodeType !== 1) {
//             return
//           }

//           var css = data.css
//           var type = data.type
//           var enterClass = data.enterClass
//           var enterToClass = data.enterToClass
//           var enterActiveClass = data.enterActiveClass
//           var appearClass = data.appearClass
//           var appearToClass = data.appearToClass
//           var appearActiveClass = data.appearActiveClass
//           var beforeEnter = data.beforeEnter
//           var enter = data.enter
//           var afterEnter = data.afterEnter
//           var enterCancelled = data.enterCancelled
//           var beforeAppear = data.beforeAppear
//           var appear = data.appear
//           var afterAppear = data.afterAppear
//           var appearCancelled = data.appearCancelled
//           var duration = data.duration

//           // activeInstance will always be the <transition> component managing this
//           // transition. One edge case to check is when the <transition> is placed
//           // as the root node of a child component. In that case we need to check
//           // <transition>'s parent for appear check.
//           var context = activeInstance
//           var transitionNode = activeInstance.$vnode
//           while (transitionNode && transitionNode.parent) {
//             transitionNode = transitionNode.parent
//             context = transitionNode.context
//           }

//           var isAppear = !context._isMounted || !vnode.isRootInsert

//           if (isAppear && !appear && appear !== '') {
//             return
//           }

//           var startClass = isAppear && appearClass
//             ? appearClass
//             : enterClass
//           var activeClass = isAppear && appearActiveClass
//             ? appearActiveClass
//             : enterActiveClass
//           var toClass = isAppear && appearToClass
//             ? appearToClass
//             : enterToClass

//           var beforeEnterHook = isAppear
//             ? (beforeAppear || beforeEnter)
//             : beforeEnter
//           var enterHook = isAppear
//             ? (typeof appear === 'function' ? appear : enter)
//             : enter
//           var afterEnterHook = isAppear
//             ? (afterAppear || afterEnter)
//             : afterEnter
//           var enterCancelledHook = isAppear
//             ? (appearCancelled || enterCancelled)
//             : enterCancelled

//           var explicitEnterDuration = toNumber(
//             isObject(duration)
//               ? duration.enter
//               : duration
//           )

//           if (true && explicitEnterDuration != null) {
//             checkDuration(explicitEnterDuration, 'enter', vnode)
//           }

//           var expectsCSS = css !== false && !isIE9
//           var userWantsControl = getHookArgumentsLength(enterHook)

//           var cb = el._enterCb = once(function () {
//             if (expectsCSS) {
//               removeTransitionClass(el, toClass)
//               removeTransitionClass(el, activeClass)
//             }
//             if (cb.cancelled) {
//               if (expectsCSS) {
//                 removeTransitionClass(el, startClass)
//               }
//               enterCancelledHook && enterCancelledHook(el)
//             } else {
//               afterEnterHook && afterEnterHook(el)
//             }
//             el._enterCb = null
//           })

//           if (!vnode.data.show) {
//             // remove pending leave element on enter by injecting an insert hook
//             mergeVNodeHook(vnode, 'insert', function () {
//               var parent = el.parentNode
//               var pendingNode = parent && parent._pending && parent._pending[vnode.key]
//               if (pendingNode &&
//         pendingNode.tag === vnode.tag &&
//         pendingNode.elm._leaveCb
//               ) {
//                 pendingNode.elm._leaveCb()
//               }
//               enterHook && enterHook(el, cb)
//             })
//           }

//           // start enter transition
//           beforeEnterHook && beforeEnterHook(el)
//           if (expectsCSS) {
//             addTransitionClass(el, startClass)
//             addTransitionClass(el, activeClass)
//             nextFrame(function () {
//               addTransitionClass(el, toClass)
//               removeTransitionClass(el, startClass)
//               if (!cb.cancelled && !userWantsControl) {
//                 if (isValidDuration(explicitEnterDuration)) {
//                   setTimeout(cb, explicitEnterDuration)
//                 } else {
//                   whenTransitionEnds(el, type, cb)
//                 }
//               }
//             })
//           }

//           if (vnode.data.show) {
//             toggleDisplay && toggleDisplay()
//             enterHook && enterHook(el, cb)
//           }

//           if (!expectsCSS && !userWantsControl) {
//             cb()
//           }
//         }

//         function leave (vnode, rm) {
//           var el = vnode.elm

//           // call enter callback now
//           if (isDef(el._enterCb)) {
//             el._enterCb.cancelled = true
//             el._enterCb()
//           }

//           var data = resolveTransition(vnode.data.transition)
//           if (isUndef(data) || el.nodeType !== 1) {
//             return rm()
//           }

//           /* istanbul ignore if */
//           if (isDef(el._leaveCb)) {
//             return
//           }

//           var css = data.css
//           var type = data.type
//           var leaveClass = data.leaveClass
//           var leaveToClass = data.leaveToClass
//           var leaveActiveClass = data.leaveActiveClass
//           var beforeLeave = data.beforeLeave
//           var leave = data.leave
//           var afterLeave = data.afterLeave
//           var leaveCancelled = data.leaveCancelled
//           var delayLeave = data.delayLeave
//           var duration = data.duration

//           var expectsCSS = css !== false && !isIE9
//           var userWantsControl = getHookArgumentsLength(leave)

//           var explicitLeaveDuration = toNumber(
//             isObject(duration)
//               ? duration.leave
//               : duration
//           )

//           if (true && isDef(explicitLeaveDuration)) {
//             checkDuration(explicitLeaveDuration, 'leave', vnode)
//           }

//           var cb = el._leaveCb = once(function () {
//             if (el.parentNode && el.parentNode._pending) {
//               el.parentNode._pending[vnode.key] = null
//             }
//             if (expectsCSS) {
//               removeTransitionClass(el, leaveToClass)
//               removeTransitionClass(el, leaveActiveClass)
//             }
//             if (cb.cancelled) {
//               if (expectsCSS) {
//                 removeTransitionClass(el, leaveClass)
//               }
//               leaveCancelled && leaveCancelled(el)
//             } else {
//               rm()
//               afterLeave && afterLeave(el)
//             }
//             el._leaveCb = null
//           })

//           if (delayLeave) {
//             delayLeave(performLeave)
//           } else {
//             performLeave()
//           }

//           function performLeave () {
//             // the delayed leave may have already been cancelled
//             if (cb.cancelled) {
//               return
//             }
//             // record leaving element
//             if (!vnode.data.show) {
//               (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode
//             }
//             beforeLeave && beforeLeave(el)
//             if (expectsCSS) {
//               addTransitionClass(el, leaveClass)
//               addTransitionClass(el, leaveActiveClass)
//               nextFrame(function () {
//                 addTransitionClass(el, leaveToClass)
//                 removeTransitionClass(el, leaveClass)
//                 if (!cb.cancelled && !userWantsControl) {
//                   if (isValidDuration(explicitLeaveDuration)) {
//                     setTimeout(cb, explicitLeaveDuration)
//                   } else {
//                     whenTransitionEnds(el, type, cb)
//                   }
//                 }
//               })
//             }
//             leave && leave(el, cb)
//             if (!expectsCSS && !userWantsControl) {
//               cb()
//             }
//           }
//         }

//         // only used in dev mode
//         function checkDuration (val, name, vnode) {
//           if (typeof val !== 'number') {
//             warn(
//               '<transition> explicit ' + name + ' duration is not a valid number - ' +
//       'got ' + (JSON.stringify(val)) + '.',
//               vnode.context
//             )
//           } else if (isNaN(val)) {
//             warn(
//               '<transition> explicit ' + name + ' duration is NaN - ' +
//       'the duration expression might be incorrect.',
//               vnode.context
//             )
//           }
//         }

//         function isValidDuration (val) {
//           return typeof val === 'number' && !isNaN(val)
//         }

//         /**
//  * Normalize a transition hook's argument length. The hook may be:
//  * - a merged hook (invoker) with the original in .fns
//  * - a wrapped component method (check ._length)
//  * - a plain function (.length)
//  */
//         function getHookArgumentsLength (fn) {
//           if (isUndef(fn)) {
//             return false
//           }
//           var invokerFns = fn.fns
//           if (isDef(invokerFns)) {
//             // invoker
//             return getHookArgumentsLength(
//               Array.isArray(invokerFns)
//                 ? invokerFns[0]
//                 : invokerFns
//             )
//           } else {
//             return (fn._length || fn.length) > 1
//           }
//         }

//         function _enter (_, vnode) {
//           if (vnode.data.show !== true) {
//             enter(vnode)
//           }
//         }

//         var transition = inBrowser ? {
//           create: _enter,
//           activate: _enter,
//           remove: function remove$$1 (vnode, rm) {
//             /* istanbul ignore else */
//             if (vnode.data.show !== true) {
//               leave(vnode, rm)
//             } else {
//               rm()
//             }
//           }
//         } : {}

//         var platformModules = [
//           attrs,
//           klass,
//           events,
//           domProps,
//           style,
//           transition
//         ]

//         /*  */

//         // the directive module should be applied last, after all
//         // built-in modules have been applied.
//         var modules = platformModules.concat(baseModules)

//         var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules })

//         /**
//  * Not type checking this file because flow doesn't like attaching
//  * properties to Elements.
//  */

//         /* istanbul ignore if */
//         if (isIE9) {
//           // http://www.matts411.com/post/internet-explorer-9-oninput/
//           document.addEventListener('selectionchange', function () {
//             var el = document.activeElement
//             if (el && el.vmodel) {
//               trigger(el, 'input')
//             }
//           })
//         }

//         var directive = {
//           inserted: function inserted (el, binding, vnode, oldVnode) {
//             if (vnode.tag === 'select') {
//               // #6903
//               if (oldVnode.elm && !oldVnode.elm._vOptions) {
//                 mergeVNodeHook(vnode, 'postpatch', function () {
//                   directive.componentUpdated(el, binding, vnode)
//                 })
//               } else {
//                 setSelected(el, binding, vnode.context)
//               }
//               el._vOptions = [].map.call(el.options, getValue)
//             } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
//               el._vModifiers = binding.modifiers
//               if (!binding.modifiers.lazy) {
//                 // Safari < 10.2 & UIWebView doesn't fire compositionend when
//                 // switching focus before confirming composition choice
//                 // this also fixes the issue where some browsers e.g. iOS Chrome
//                 // fires "change" instead of "input" on autocomplete.
//                 el.addEventListener('change', onCompositionEnd)
//                 if (!isAndroid) {
//                   el.addEventListener('compositionstart', onCompositionStart)
//                   el.addEventListener('compositionend', onCompositionEnd)
//                 }
//                 /* istanbul ignore if */
//                 if (isIE9) {
//                   el.vmodel = true
//                 }
//               }
//             }
//           },

//           componentUpdated: function componentUpdated (el, binding, vnode) {
//             if (vnode.tag === 'select') {
//               setSelected(el, binding, vnode.context)
//               // in case the options rendered by v-for have changed,
//               // it's possible that the value is out-of-sync with the rendered options.
//               // detect such cases and filter out values that no longer has a matching
//               // option in the DOM.
//               var prevOptions = el._vOptions
//               var curOptions = el._vOptions = [].map.call(el.options, getValue)
//               if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]) })) {
//                 // trigger change event if
//                 // no matching option found for at least one value
//                 var needReset = el.multiple
//                   ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions) })
//                   : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions)
//                 if (needReset) {
//                   trigger(el, 'change')
//                 }
//               }
//             }
//           }
//         }

//         function setSelected (el, binding, vm) {
//           actuallySetSelected(el, binding, vm)
//           /* istanbul ignore if */
//           if (isIE || isEdge) {
//             setTimeout(function () {
//               actuallySetSelected(el, binding, vm)
//             }, 0)
//           }
//         }

//         function actuallySetSelected (el, binding, vm) {
//           var value = binding.value
//           var isMultiple = el.multiple
//           if (isMultiple && !Array.isArray(value)) {
//             true && warn(
//               '<select multiple v-model="' + (binding.expression) + '"> ' +
//       'expects an Array value for its binding, but got ' + (Object.prototype.toString.call(value).slice(8, -1)),
//               vm
//             )
//             return
//           }
//           var selected, option
//           for (var i = 0, l = el.options.length; i < l; i++) {
//             option = el.options[i]
//             if (isMultiple) {
//               selected = looseIndexOf(value, getValue(option)) > -1
//               if (option.selected !== selected) {
//                 option.selected = selected
//               }
//             } else {
//               if (looseEqual(getValue(option), value)) {
//                 if (el.selectedIndex !== i) {
//                   el.selectedIndex = i
//                 }
//                 return
//               }
//             }
//           }
//           if (!isMultiple) {
//             el.selectedIndex = -1
//           }
//         }

//         function hasNoMatchingOption (value, options) {
//           return options.every(function (o) { return !looseEqual(o, value) })
//         }

//         function getValue (option) {
//           return '_value' in option
//             ? option._value
//             : option.value
//         }

//         function onCompositionStart (e) {
//           e.target.composing = true
//         }

//         function onCompositionEnd (e) {
//           // prevent triggering an input event for no reason
//           if (!e.target.composing) { return }
//           e.target.composing = false
//           trigger(e.target, 'input')
//         }

//         function trigger (el, type) {
//           var e = document.createEvent('HTMLEvents')
//           e.initEvent(type, true, true)
//           el.dispatchEvent(e)
//         }

//         /*  */

//         // recursively search for possible transition defined inside the component root
//         function locateNode (vnode) {
//           return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
//             ? locateNode(vnode.componentInstance._vnode)
//             : vnode
//         }

//         var show = {
//           bind: function bind (el, ref, vnode) {
//             var value = ref.value

//             vnode = locateNode(vnode)
//             var transition$$1 = vnode.data && vnode.data.transition
//             var originalDisplay = el.__vOriginalDisplay =
//       el.style.display === 'none' ? '' : el.style.display
//             if (value && transition$$1) {
//               vnode.data.show = true
//               enter(vnode, function () {
//                 el.style.display = originalDisplay
//               })
//             } else {
//               el.style.display = value ? originalDisplay : 'none'
//             }
//           },

//           update: function update (el, ref, vnode) {
//             var value = ref.value
//             var oldValue = ref.oldValue

//             /* istanbul ignore if */
//             if (value === oldValue) { return }
//             vnode = locateNode(vnode)
//             var transition$$1 = vnode.data && vnode.data.transition
//             if (transition$$1) {
//               vnode.data.show = true
//               if (value) {
//                 enter(vnode, function () {
//                   el.style.display = el.__vOriginalDisplay
//                 })
//               } else {
//                 leave(vnode, function () {
//                   el.style.display = 'none'
//                 })
//               }
//             } else {
//               el.style.display = value ? el.__vOriginalDisplay : 'none'
//             }
//           },

//           unbind: function unbind (
//             el,
//             binding,
//             vnode,
//             oldVnode,
//             isDestroy
//           ) {
//             if (!isDestroy) {
//               el.style.display = el.__vOriginalDisplay
//             }
//           }
//         }

//         var platformDirectives = {
//           model: directive,
//           show: show
//         }

//         /*  */

//         // Provides transition support for a single element/component.
//         // supports transition mode (out-in / in-out)

//         var transitionProps = {
//           name: String,
//           appear: Boolean,
//           css: Boolean,
//           mode: String,
//           type: String,
//           enterClass: String,
//           leaveClass: String,
//           enterToClass: String,
//           leaveToClass: String,
//           enterActiveClass: String,
//           leaveActiveClass: String,
//           appearClass: String,
//           appearActiveClass: String,
//           appearToClass: String,
//           duration: [Number, String, Object]
//         }

//         // in case the child is also an abstract component, e.g. <keep-alive>
//         // we want to recursively retrieve the real component to be rendered
//         function getRealChild (vnode) {
//           var compOptions = vnode && vnode.componentOptions
//           if (compOptions && compOptions.Ctor.options.abstract) {
//             return getRealChild(getFirstComponentChild(compOptions.children))
//           } else {
//             return vnode
//           }
//         }

//         function extractTransitionData (comp) {
//           var data = {}
//           var options = comp.$options
//           // props
//           for (var key in options.propsData) {
//             data[key] = comp[key]
//           }
//           // events.
//           // extract listeners and pass them directly to the transition methods
//           var listeners = options._parentListeners
//           for (var key$1 in listeners) {
//             data[camelize(key$1)] = listeners[key$1]
//           }
//           return data
//         }

//         function placeholder (h, rawChild) {
//           if (/\d-keep-alive$/.test(rawChild.tag)) {
//             return h('keep-alive', {
//               props: rawChild.componentOptions.propsData
//             })
//           }
//         }

//         function hasParentTransition (vnode) {
//           while ((vnode = vnode.parent)) {
//             if (vnode.data.transition) {
//               return true
//             }
//           }
//         }

//         function isSameChild (child, oldChild) {
//           return oldChild.key === child.key && oldChild.tag === child.tag
//         }

//         var Transition = {
//           name: 'transition',
//           props: transitionProps,
//           abstract: true,

//           render: function render (h) {
//             var this$1 = this

//             var children = this.$slots.default
//             if (!children) {
//               return
//             }

//             // filter out text nodes (possible whitespaces)
//             children = children.filter(function (c) { return c.tag || isAsyncPlaceholder(c) })
//             /* istanbul ignore if */
//             if (!children.length) {
//               return
//             }

//             // warn multiple elements
//             if (true && children.length > 1) {
//               warn(
//                 '<transition> can only be used on a single element. Use ' +
//         '<transition-group> for lists.',
//                 this.$parent
//               )
//             }

//             var mode = this.mode

//             // warn invalid mode
//             if (true &&
//       mode && mode !== 'in-out' && mode !== 'out-in'
//             ) {
//               warn(
//                 'invalid <transition> mode: ' + mode,
//                 this.$parent
//               )
//             }

//             var rawChild = children[0]

//             // if this is a component root node and the component's
//             // parent container node also has transition, skip.
//             if (hasParentTransition(this.$vnode)) {
//               return rawChild
//             }

//             // apply transition data to child
//             // use getRealChild() to ignore abstract components e.g. keep-alive
//             var child = getRealChild(rawChild)
//             /* istanbul ignore if */
//             if (!child) {
//               return rawChild
//             }

//             if (this._leaving) {
//               return placeholder(h, rawChild)
//             }

//             // ensure a key that is unique to the vnode type and to this transition
//             // component instance. This key will be used to remove pending leaving nodes
//             // during entering.
//             var id = '__transition-' + (this._uid) + '-'
//             child.key = child.key == null
//               ? child.isComment
//                 ? id + 'comment'
//                 : id + child.tag
//               : isPrimitive(child.key)
//                 ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
//                 : child.key

//             var data = (child.data || (child.data = {})).transition = extractTransitionData(this)
//             var oldRawChild = this._vnode
//             var oldChild = getRealChild(oldRawChild)

//             // mark v-show
//             // so that the transition module can hand over the control to the directive
//             if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show' })) {
//               child.data.show = true
//             }

//             if (
//               oldChild &&
//       oldChild.data &&
//       !isSameChild(child, oldChild) &&
//       !isAsyncPlaceholder(oldChild) &&
//       // #6687 component root is a comment node
//       !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
//             ) {
//               // replace old child transition data with fresh one
//               // important for dynamic transitions!
//               var oldData = oldChild.data.transition = extend({}, data)
//               // handle transition mode
//               if (mode === 'out-in') {
//                 // return placeholder node and queue update when leave finishes
//                 this._leaving = true
//                 mergeVNodeHook(oldData, 'afterLeave', function () {
//                   this$1._leaving = false
//                   this$1.$forceUpdate()
//                 })
//                 return placeholder(h, rawChild)
//               } else if (mode === 'in-out') {
//                 if (isAsyncPlaceholder(child)) {
//                   return oldRawChild
//                 }
//                 var delayedLeave
//                 var performLeave = function () { delayedLeave() }
//                 mergeVNodeHook(data, 'afterEnter', performLeave)
//                 mergeVNodeHook(data, 'enterCancelled', performLeave)
//                 mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave })
//               }
//             }

//             return rawChild
//           }
//         }

//         /*  */

//         // Provides transition support for list items.
//         // supports move transitions using the FLIP technique.

//         // Because the vdom's children update algorithm is "unstable" - i.e.
//         // it doesn't guarantee the relative positioning of removed elements,
//         // we force transition-group to update its children into two passes:
//         // in the first pass, we remove all nodes that need to be removed,
//         // triggering their leaving transition; in the second pass, we insert/move
//         // into the final desired state. This way in the second pass removed
//         // nodes will remain where they should be.

//         var props = extend({
//           tag: String,
//           moveClass: String
//         }, transitionProps)

//         delete props.mode

//         var TransitionGroup = {
//           props: props,

//           render: function render (h) {
//             var tag = this.tag || this.$vnode.data.tag || 'span'
//             var map = Object.create(null)
//             var prevChildren = this.prevChildren = this.children
//             var rawChildren = this.$slots.default || []
//             var children = this.children = []
//             var transitionData = extractTransitionData(this)

//             for (var i = 0; i < rawChildren.length; i++) {
//               var c = rawChildren[i]
//               if (c.tag) {
//                 if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
//                   children.push(c)
//                   map[c.key] = c
//                   ;(c.data || (c.data = {})).transition = transitionData
//                 } else if (true) {
//                   var opts = c.componentOptions
//                   var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag
//                   warn(('<transition-group> children must be keyed: <' + name + '>'))
//                 }
//               }
//             }

//             if (prevChildren) {
//               var kept = []
//               var removed = []
//               for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
//                 var c$1 = prevChildren[i$1]
//                 c$1.data.transition = transitionData
//                 c$1.data.pos = c$1.elm.getBoundingClientRect()
//                 if (map[c$1.key]) {
//                   kept.push(c$1)
//                 } else {
//                   removed.push(c$1)
//                 }
//               }
//               this.kept = h(tag, null, kept)
//               this.removed = removed
//             }

//             return h(tag, null, children)
//           },

//           beforeUpdate: function beforeUpdate () {
//             // force removing pass
//             this.__patch__(
//               this._vnode,
//               this.kept,
//               false, // hydrating
//               true // removeOnly (!important avoids unnecessary moves)
//             )
//             this._vnode = this.kept
//           },

//           updated: function updated () {
//             var children = this.prevChildren
//             var moveClass = this.moveClass || ((this.name || 'v') + '-move')
//             if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
//               return
//             }

//             // we divide the work into three loops to avoid mixing DOM reads and writes
//             // in each iteration - which helps prevent layout thrashing.
//             children.forEach(callPendingCbs)
//             children.forEach(recordPosition)
//             children.forEach(applyTranslation)

//             // force reflow to put everything in position
//             // assign to this to avoid being removed in tree-shaking
//             // $flow-disable-line
//             this._reflow = document.body.offsetHeight

//             children.forEach(function (c) {
//               if (c.data.moved) {
//                 var el = c.elm
//                 var s = el.style
//                 addTransitionClass(el, moveClass)
//                 s.transform = s.WebkitTransform = s.transitionDuration = ''
//                 el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
//                   if (!e || /transform$/.test(e.propertyName)) {
//                     el.removeEventListener(transitionEndEvent, cb)
//                     el._moveCb = null
//                     removeTransitionClass(el, moveClass)
//                   }
//                 })
//               }
//             })
//           },

//           methods: {
//             hasMove: function hasMove (el, moveClass) {
//               /* istanbul ignore if */
//               if (!hasTransition) {
//                 return false
//               }
//               /* istanbul ignore if */
//               if (this._hasMove) {
//                 return this._hasMove
//               }
//               // Detect whether an element with the move class applied has
//               // CSS transitions. Since the element may be inside an entering
//               // transition at this very moment, we make a clone of it and remove
//               // all other transition classes applied to ensure only the move class
//               // is applied.
//               var clone = el.cloneNode()
//               if (el._transitionClasses) {
//                 el._transitionClasses.forEach(function (cls) { removeClass(clone, cls) })
//               }
//               addClass(clone, moveClass)
//               clone.style.display = 'none'
//               this.$el.appendChild(clone)
//               var info = getTransitionInfo(clone)
//               this.$el.removeChild(clone)
//               return (this._hasMove = info.hasTransform)
//             }
//           }
//         }

//         function callPendingCbs (c) {
//           /* istanbul ignore if */
//           if (c.elm._moveCb) {
//             c.elm._moveCb()
//           }
//           /* istanbul ignore if */
//           if (c.elm._enterCb) {
//             c.elm._enterCb()
//           }
//         }

//         function recordPosition (c) {
//           c.data.newPos = c.elm.getBoundingClientRect()
//         }

//         function applyTranslation (c) {
//           var oldPos = c.data.pos
//           var newPos = c.data.newPos
//           var dx = oldPos.left - newPos.left
//           var dy = oldPos.top - newPos.top
//           if (dx || dy) {
//             c.data.moved = true
//             var s = c.elm.style
//             s.transform = s.WebkitTransform = 'translate(' + dx + 'px,' + dy + 'px)'
//             s.transitionDuration = '0s'
//           }
//         }

//         var platformComponents = {
//           Transition: Transition,
//           TransitionGroup: TransitionGroup
//         }

//         /*  */

//         // install platform specific utils
//         Vue$3.config.mustUseProp = mustUseProp
//         Vue$3.config.isReservedTag = isReservedTag
//         Vue$3.config.isReservedAttr = isReservedAttr
//         Vue$3.config.getTagNamespace = getTagNamespace
//         Vue$3.config.isUnknownElement = isUnknownElement

//         // install platform runtime directives & components
//         extend(Vue$3.options.directives, platformDirectives)
//         extend(Vue$3.options.components, platformComponents)

//         // install platform patch function
//         Vue$3.prototype.__patch__ = inBrowser ? patch : noop

//         // public mount method
//         Vue$3.prototype.$mount = function (
//           el,
//           hydrating
//         ) {
//           el = el && inBrowser ? query(el) : undefined
//           return mountComponent(this, el, hydrating)
//         }

//         // devtools global hook
//         /* istanbul ignore next */
//         Vue$3.nextTick(function () {
//           if (config.devtools) {
//             if (devtools) {
//               devtools.emit('init', Vue$3)
//             } else if (true && isChrome) {
//               console[console.info ? 'info' : 'log'](
//                 'Download the Vue Devtools extension for a better development experience:\n' +
//         'https://github.com/vuejs/vue-devtools'
//               )
//             }
//           }
//           if (true &&
//     config.productionTip !== false &&
//     inBrowser && typeof console !== 'undefined'
//           ) {
//             console[console.info ? 'info' : 'log'](
//               'You are running Vue in development mode.\n' +
//       'Make sure to turn on production mode when deploying for production.\n' +
//       'See more tips at https://vuejs.org/guide/deployment.html'
//             )
//           }
//         }, 0)

//         /*  */

//         /* harmony default export */ __webpack_exports__['default'] = (Vue$3)
//         /* WEBPACK VAR INJECTION */ }.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ './node_modules/webpack/buildin/global.js'), __webpack_require__(/*! ./../../timers-browserify/main.js */ './node_modules/timers-browserify/main.js').setImmediate))
//       /** */ },

//     /** */ './node_modules/webpack/buildin/global.js':
//     /*! ***********************************!*\
//   !*** (webpack)/buildin/global.js ***!
//   \***********************************/
//     /*! no static exports found */
//     /** */ function (module, exports) {
//       var g

//       // This works in non-strict mode
//       g = (function () {
//         return this
//       })()

//       try {
//         // This works if eval is allowed (see CSP)
//         g = g || new Function('return this')()
//       } catch (e) {
//         // This works if the window reference is available
//         if (typeof window === 'object') g = window
//       }

//       // g can still be undefined, but nothing to do about it...
//       // We return undefined, instead of nothing here, so it's
//       // easier to handle this case. if(!global) { ...}

//       module.exports = g
//       /** */ },

//     /** */ './src/EventBus.js':
//     /*! *************************!*\
//   !*** ./src/EventBus.js ***!
//   \*************************/
//     /*! exports provided: EventBus */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, 'EventBus', function () { return EventBus })
//       /* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue */ './node_modules/vue/dist/vue.runtime.esm.js')

//       var EventBus = function EventBus () {
//         return new vue__WEBPACK_IMPORTED_MODULE_0__['default']()
//       }
//       /** */ },

//     /** */ './src/Scope.vue':
//     /*! ***********************!*\
//   !*** ./src/Scope.vue ***!
//   \***********************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _Scope_vue_vue_type_template_id_4c74502b_scoped_true___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Scope.vue?vue&type=template&id=4c74502b&scoped=true& */ './src/Scope.vue?vue&type=template&id=4c74502b&scoped=true&')
//       /* harmony import */ var _Scope_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Scope.vue?vue&type=script&lang=js& */ './src/Scope.vue?vue&type=script&lang=js&')
//       /* empty/unused harmony star reexport *//* harmony import */ var _Scope_vue_vue_type_style_index_0_id_4c74502b_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css& */ './src/Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css&')
//       /* harmony import */ var _node_modules_poi_node_modules_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../node_modules/poi/node_modules/vue-loader/lib/runtime/componentNormalizer.js */ './node_modules/poi/node_modules/vue-loader/lib/runtime/componentNormalizer.js')

//       /* normalize component */

//       var component = Object(_node_modules_poi_node_modules_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__['default'])(
//         _Scope_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__['default'],
//         _Scope_vue_vue_type_template_id_4c74502b_scoped_true___WEBPACK_IMPORTED_MODULE_0__['render'],
//         _Scope_vue_vue_type_template_id_4c74502b_scoped_true___WEBPACK_IMPORTED_MODULE_0__['staticRenderFns'],
//         false,
//         null,
//         '4c74502b',
//         null

//       )

//       /* hot reload */
//       if (false) { var api }
//       component.options.__file = 'src/Scope.vue'
//       /* harmony default export */ __webpack_exports__['default'] = (component.exports)
//       /** */ },

//     /** */ './src/Scope.vue?vue&type=script&lang=js&':
//     /*! ************************************************!*\
//   !*** ./src/Scope.vue?vue&type=script&lang=js& ***!
//   \************************************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _node_modules_poi_lib_webpack_babel_loader_js_ref_1_0_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_Scope_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!../node_modules/poi/lib/webpack/babel-loader.js??ref--1-0!../node_modules/cache-loader/dist/cjs.js??ref--2-0!../node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./Scope.vue?vue&type=script&lang=js& */ './node_modules/poi/lib/webpack/babel-loader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/Scope.vue?vue&type=script&lang=js&')
//       /* empty/unused harmony star reexport */ /* harmony default export */ __webpack_exports__['default'] = (_node_modules_poi_lib_webpack_babel_loader_js_ref_1_0_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_Scope_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_0__['default'])
//       /** */ },

//     /** */ './src/Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css&':
//     /*! ********************************************************************************!*\
//   !*** ./src/Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css& ***!
//   \********************************************************************************/
//     /*! no static exports found */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_Scope_vue_vue_type_style_index_0_id_4c74502b_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!../node_modules/vue-style-loader??ref--3-oneOf-1-0!../node_modules/css-loader??ref--3-oneOf-1-1!../node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!../node_modules/cache-loader/dist/cjs.js??ref--2-0!../node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css& */ './node_modules/vue-style-loader/index.js?!./node_modules/css-loader/index.js?!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/Scope.vue?vue&type=style&index=0&id=4c74502b&scoped=true&lang=css&')
//       /* harmony import */ var _node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_Scope_vue_vue_type_style_index_0_id_4c74502b_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0___default = /* #__PURE__*/__webpack_require__.n(_node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_Scope_vue_vue_type_style_index_0_id_4c74502b_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0__)
//       /* harmony reexport (unknown) */ for (var __WEBPACK_IMPORT_KEY__ in _node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_Scope_vue_vue_type_style_index_0_id_4c74502b_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0__) if (__WEBPACK_IMPORT_KEY__ !== 'default') (function (key) { __webpack_require__.d(__webpack_exports__, key, function () { return _node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_Scope_vue_vue_type_style_index_0_id_4c74502b_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0__[key] }) }(__WEBPACK_IMPORT_KEY__))
//       /* harmony default export */ __webpack_exports__['default'] = (_node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_Scope_vue_vue_type_style_index_0_id_4c74502b_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0___default.a)
//       /** */ },

//     /** */ './src/Scope.vue?vue&type=template&id=4c74502b&scoped=true&':
//     /*! ******************************************************************!*\
//   !*** ./src/Scope.vue?vue&type=template&id=4c74502b&scoped=true& ***!
//   \******************************************************************/
//     /*! exports provided: render, staticRenderFns */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _cache_loader_cacheDirectory_node_modules_cache_vue_loader_cacheIdentifier_0a85af55_vue_loader_template_node_modules_poi_node_modules_vue_loader_lib_loaders_templateLoader_js_vue_loader_options_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_Scope_vue_vue_type_template_id_4c74502b_scoped_true___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!cache-loader?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!../node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!../node_modules/cache-loader/dist/cjs.js??ref--2-0!../node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./Scope.vue?vue&type=template&id=4c74502b&scoped=true& */ './node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!./node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/Scope.vue?vue&type=template&id=4c74502b&scoped=true&')
//       /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, 'render', function () { return _cache_loader_cacheDirectory_node_modules_cache_vue_loader_cacheIdentifier_0a85af55_vue_loader_template_node_modules_poi_node_modules_vue_loader_lib_loaders_templateLoader_js_vue_loader_options_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_Scope_vue_vue_type_template_id_4c74502b_scoped_true___WEBPACK_IMPORTED_MODULE_0__['render'] })

//       /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, 'staticRenderFns', function () { return _cache_loader_cacheDirectory_node_modules_cache_vue_loader_cacheIdentifier_0a85af55_vue_loader_template_node_modules_poi_node_modules_vue_loader_lib_loaders_templateLoader_js_vue_loader_options_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_Scope_vue_vue_type_template_id_4c74502b_scoped_true___WEBPACK_IMPORTED_MODULE_0__['staticRenderFns'] })
//       /** */ },

//     /** */ './src/SvgPanZoom.vue':
//     /*! ****************************!*\
//   !*** ./src/SvgPanZoom.vue ***!
//   \****************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _SvgPanZoom_vue_vue_type_template_id_806a3476___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./SvgPanZoom.vue?vue&type=template&id=806a3476& */ './src/SvgPanZoom.vue?vue&type=template&id=806a3476&')
//       /* harmony import */ var _SvgPanZoom_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./SvgPanZoom.vue?vue&type=script&lang=js& */ './src/SvgPanZoom.vue?vue&type=script&lang=js&')
//       /* empty/unused harmony star reexport *//* harmony import */ var _node_modules_poi_node_modules_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../node_modules/poi/node_modules/vue-loader/lib/runtime/componentNormalizer.js */ './node_modules/poi/node_modules/vue-loader/lib/runtime/componentNormalizer.js')

//       /* normalize component */

//       var component = Object(_node_modules_poi_node_modules_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_2__['default'])(
//         _SvgPanZoom_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__['default'],
//         _SvgPanZoom_vue_vue_type_template_id_806a3476___WEBPACK_IMPORTED_MODULE_0__['render'],
//         _SvgPanZoom_vue_vue_type_template_id_806a3476___WEBPACK_IMPORTED_MODULE_0__['staticRenderFns'],
//         false,
//         null,
//         null,
//         null

//       )

//       /* hot reload */
//       if (false) { var api }
//       component.options.__file = 'src/SvgPanZoom.vue'
//       /* harmony default export */ __webpack_exports__['default'] = (component.exports)
//       /** */ },

//     /** */ './src/SvgPanZoom.vue?vue&type=script&lang=js&':
//     /*! *****************************************************!*\
//   !*** ./src/SvgPanZoom.vue?vue&type=script&lang=js& ***!
//   \*****************************************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _node_modules_poi_lib_webpack_babel_loader_js_ref_1_0_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoom_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!../node_modules/poi/lib/webpack/babel-loader.js??ref--1-0!../node_modules/cache-loader/dist/cjs.js??ref--2-0!../node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./SvgPanZoom.vue?vue&type=script&lang=js& */ './node_modules/poi/lib/webpack/babel-loader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoom.vue?vue&type=script&lang=js&')
//       /* empty/unused harmony star reexport */ /* harmony default export */ __webpack_exports__['default'] = (_node_modules_poi_lib_webpack_babel_loader_js_ref_1_0_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoom_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_0__['default'])
//       /** */ },

//     /** */ './src/SvgPanZoom.vue?vue&type=template&id=806a3476&':
//     /*! ***********************************************************!*\
//   !*** ./src/SvgPanZoom.vue?vue&type=template&id=806a3476& ***!
//   \***********************************************************/
//     /*! exports provided: render, staticRenderFns */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _cache_loader_cacheDirectory_node_modules_cache_vue_loader_cacheIdentifier_0a85af55_vue_loader_template_node_modules_poi_node_modules_vue_loader_lib_loaders_templateLoader_js_vue_loader_options_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoom_vue_vue_type_template_id_806a3476___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!cache-loader?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!../node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!../node_modules/cache-loader/dist/cjs.js??ref--2-0!../node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./SvgPanZoom.vue?vue&type=template&id=806a3476& */ './node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!./node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoom.vue?vue&type=template&id=806a3476&')
//       /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, 'render', function () { return _cache_loader_cacheDirectory_node_modules_cache_vue_loader_cacheIdentifier_0a85af55_vue_loader_template_node_modules_poi_node_modules_vue_loader_lib_loaders_templateLoader_js_vue_loader_options_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoom_vue_vue_type_template_id_806a3476___WEBPACK_IMPORTED_MODULE_0__['render'] })

//       /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, 'staticRenderFns', function () { return _cache_loader_cacheDirectory_node_modules_cache_vue_loader_cacheIdentifier_0a85af55_vue_loader_template_node_modules_poi_node_modules_vue_loader_lib_loaders_templateLoader_js_vue_loader_options_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoom_vue_vue_type_template_id_806a3476___WEBPACK_IMPORTED_MODULE_0__['staticRenderFns'] })
//       /** */ },

//     /** */ './src/SvgPanZoomApi.js':
//     /*! ******************************!*\
//   !*** ./src/SvgPanZoomApi.js ***!
//   \******************************/
//     /*! exports provided: SvgPanZoomApi */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, 'SvgPanZoomApi', function () { return SvgPanZoomApi })
//       var SvgPanZoomApi = function SvgPanZoomApi (SvgPanZoomInstance) {
//         return {
//           zoom: function zoom (v) {
//             SvgPanZoomInstance.zoom(v)
//           },
//           zoomBy: function zoomBy (v) {
//             return SvgPanZoomInstance.zoomBy(v)
//           }
//         }
//       }
//       /** */ },

//     /** */ './src/SvgPanZoomThumbnail.vue':
//     /*! *************************************!*\
//   !*** ./src/SvgPanZoomThumbnail.vue ***!
//   \*************************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _SvgPanZoomThumbnail_vue_vue_type_template_id_4cd02652___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./SvgPanZoomThumbnail.vue?vue&type=template&id=4cd02652& */ './src/SvgPanZoomThumbnail.vue?vue&type=template&id=4cd02652&')
//       /* harmony import */ var _SvgPanZoomThumbnail_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./SvgPanZoomThumbnail.vue?vue&type=script&lang=js& */ './src/SvgPanZoomThumbnail.vue?vue&type=script&lang=js&')
//       /* empty/unused harmony star reexport *//* harmony import */ var _SvgPanZoomThumbnail_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css& */ './src/SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css&')
//       /* harmony import */ var _node_modules_poi_node_modules_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../node_modules/poi/node_modules/vue-loader/lib/runtime/componentNormalizer.js */ './node_modules/poi/node_modules/vue-loader/lib/runtime/componentNormalizer.js')

//       /* normalize component */

//       var component = Object(_node_modules_poi_node_modules_vue_loader_lib_runtime_componentNormalizer_js__WEBPACK_IMPORTED_MODULE_3__['default'])(
//         _SvgPanZoomThumbnail_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_1__['default'],
//         _SvgPanZoomThumbnail_vue_vue_type_template_id_4cd02652___WEBPACK_IMPORTED_MODULE_0__['render'],
//         _SvgPanZoomThumbnail_vue_vue_type_template_id_4cd02652___WEBPACK_IMPORTED_MODULE_0__['staticRenderFns'],
//         false,
//         null,
//         null,
//         null

//       )

//       /* hot reload */
//       if (false) { var api }
//       component.options.__file = 'src/SvgPanZoomThumbnail.vue'
//       /* harmony default export */ __webpack_exports__['default'] = (component.exports)
//       /** */ },

//     /** */ './src/SvgPanZoomThumbnail.vue?vue&type=script&lang=js&':
//     /*! **************************************************************!*\
//   !*** ./src/SvgPanZoomThumbnail.vue?vue&type=script&lang=js& ***!
//   \**************************************************************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _node_modules_poi_lib_webpack_babel_loader_js_ref_1_0_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoomThumbnail_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!../node_modules/poi/lib/webpack/babel-loader.js??ref--1-0!../node_modules/cache-loader/dist/cjs.js??ref--2-0!../node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./SvgPanZoomThumbnail.vue?vue&type=script&lang=js& */ './node_modules/poi/lib/webpack/babel-loader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoomThumbnail.vue?vue&type=script&lang=js&')
//       /* empty/unused harmony star reexport */ /* harmony default export */ __webpack_exports__['default'] = (_node_modules_poi_lib_webpack_babel_loader_js_ref_1_0_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoomThumbnail_vue_vue_type_script_lang_js___WEBPACK_IMPORTED_MODULE_0__['default'])
//       /** */ },

//     /** */ './src/SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css&':
//     /*! **********************************************************************!*\
//   !*** ./src/SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css& ***!
//   \**********************************************************************/
//     /*! no static exports found */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoomThumbnail_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!../node_modules/vue-style-loader??ref--3-oneOf-1-0!../node_modules/css-loader??ref--3-oneOf-1-1!../node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!../node_modules/cache-loader/dist/cjs.js??ref--2-0!../node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css& */ './node_modules/vue-style-loader/index.js?!./node_modules/css-loader/index.js?!./node_modules/poi/node_modules/vue-loader/lib/loaders/stylePostLoader.js!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoomThumbnail.vue?vue&type=style&index=0&lang=css&')
//       /* harmony import */ var _node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoomThumbnail_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0___default = /* #__PURE__*/__webpack_require__.n(_node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoomThumbnail_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0__)
//       /* harmony reexport (unknown) */ for (var __WEBPACK_IMPORT_KEY__ in _node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoomThumbnail_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0__) if (__WEBPACK_IMPORT_KEY__ !== 'default') (function (key) { __webpack_require__.d(__webpack_exports__, key, function () { return _node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoomThumbnail_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0__[key] }) }(__WEBPACK_IMPORT_KEY__))
//       /* harmony default export */ __webpack_exports__['default'] = (_node_modules_vue_style_loader_index_js_ref_3_oneOf_1_0_node_modules_css_loader_index_js_ref_3_oneOf_1_1_node_modules_poi_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoomThumbnail_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0___default.a)
//       /** */ },

//     /** */ './src/SvgPanZoomThumbnail.vue?vue&type=template&id=4cd02652&':
//     /*! ********************************************************************!*\
//   !*** ./src/SvgPanZoomThumbnail.vue?vue&type=template&id=4cd02652& ***!
//   \********************************************************************/
//     /*! exports provided: render, staticRenderFns */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _cache_loader_cacheDirectory_node_modules_cache_vue_loader_cacheIdentifier_0a85af55_vue_loader_template_node_modules_poi_node_modules_vue_loader_lib_loaders_templateLoader_js_vue_loader_options_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoomThumbnail_vue_vue_type_template_id_4cd02652___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!cache-loader?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!../node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!../node_modules/cache-loader/dist/cjs.js??ref--2-0!../node_modules/poi/node_modules/vue-loader/lib??vue-loader-options!./SvgPanZoomThumbnail.vue?vue&type=template&id=4cd02652& */ './node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"0a85af55-vue-loader-template"}!./node_modules/poi/node_modules/vue-loader/lib/loaders/templateLoader.js?!./node_modules/cache-loader/dist/cjs.js?!./node_modules/poi/node_modules/vue-loader/lib/index.js?!./src/SvgPanZoomThumbnail.vue?vue&type=template&id=4cd02652&')
//       /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, 'render', function () { return _cache_loader_cacheDirectory_node_modules_cache_vue_loader_cacheIdentifier_0a85af55_vue_loader_template_node_modules_poi_node_modules_vue_loader_lib_loaders_templateLoader_js_vue_loader_options_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoomThumbnail_vue_vue_type_template_id_4cd02652___WEBPACK_IMPORTED_MODULE_0__['render'] })

//       /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, 'staticRenderFns', function () { return _cache_loader_cacheDirectory_node_modules_cache_vue_loader_cacheIdentifier_0a85af55_vue_loader_template_node_modules_poi_node_modules_vue_loader_lib_loaders_templateLoader_js_vue_loader_options_node_modules_cache_loader_dist_cjs_js_ref_2_0_node_modules_poi_node_modules_vue_loader_lib_index_js_vue_loader_options_SvgPanZoomThumbnail_vue_vue_type_template_id_4cd02652___WEBPACK_IMPORTED_MODULE_0__['staticRenderFns'] })
//       /** */ },

//     /** */ './src/index.js':
//     /*! **********************!*\
//   !*** ./src/index.js ***!
//   \**********************/
//     /*! exports provided: SvgPanZoom, default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony import */ var _SvgPanZoom_vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./SvgPanZoom.vue */ './src/SvgPanZoom.vue')
//       /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, 'SvgPanZoom', function () { return _SvgPanZoom_vue__WEBPACK_IMPORTED_MODULE_0__['default'] })

//       /* harmony import */ var _SvgPanZoomThumbnail_vue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./SvgPanZoomThumbnail.vue */ './src/SvgPanZoomThumbnail.vue')

//       /* harmony default export */ __webpack_exports__['default'] = (_SvgPanZoom_vue__WEBPACK_IMPORTED_MODULE_0__['default'])
//       /** */ },

//     /** */ './src/props.js':
//     /*! **********************!*\
//   !*** ./src/props.js ***!
//   \**********************/
//     /*! exports provided: default */
//     /** */ function (module, __webpack_exports__, __webpack_require__) {
//       'use strict'
//       __webpack_require__.r(__webpack_exports__)
//       /* harmony default export */ __webpack_exports__['default'] = ({
//         zoomEnabled: {
//           type: Boolean,
//           'default': true
//         },
//         controlIconsEnabled: {
//           type: Boolean,
//           'default': false
//         },
//         fit: {
//           type: Boolean,
//           'default': true
//         },
//         panEnabled: {
//           type: Boolean,
//           'default': true
//         },
//         dblClickZoomEnabled: {
//           type: Boolean,
//           'default': true
//         },
//         mouseWheelZoomEnabled: {
//           type: Boolean,
//           'default': true
//         },
//         preventMouseEventsDefault: {
//           type: Boolean,
//           'default': true
//         },
//         contain: {
//           type: Boolean,
//           'default': false
//         },
//         center: {
//           type: Boolean,
//           'default': true
//         },
//         viewportSelector: {
//           'default': '.svg-pan-zoom_viewport'
//         },
//         zoomScaleSensitivity: {
//           'default': 0.2
//         },
//         minZoom: {
//           'default': 0.5
//         },
//         maxZoom: {
//           'default': 10
//         },
//         refreshRate: {
//           'default': 'auto'
//         },
//         beforeZoom: {},
//         onZoom: {},
//         beforePan: {},
//         onPan: {},
//         onUpdatedCTM: {},
//         customEventsHandler: {},
//         eventsListenerElement: {},
//         onThumbnailShown: {}
//       })
//       /** */ },

//     /** */ 0:
//     /*! ****************************!*\
//   !*** multi ./src/index.js ***!
//   \****************************/
//     /*! no static exports found */
//     /** */ function (module, exports, __webpack_require__) {
//       module.exports = __webpack_require__(/*! ./src/index.js */'./src/index.js')
//       /** */ }

//     /** ****/ })
// // # sourceMappingURL=index.js.map
